Switching MediaStreamsManager from using AudioManager interface to AudioSystem one.

content/browser/renderer_host/media/media_devices_manager.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 "content/browser/renderer_host/media/media_devices_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/audio/audio_device_description.h"
-#include "media/audio/audio_manager.h"
+#include "media/audio/audio_system.h"
 #include "media/base/media_switches.h"
 
 #if defined(OS_MACOSX)
 #include "base/bind_helpers.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "content/browser/browser_main_loop.h"
 #include "media/device_monitors/device_monitor_mac.h"
 #endif
 
 namespace content {
 
 namespace {
 
 // Private helper method to generate a string for the log message that lists the
 // human readable names of |devices|.
 std::string GetLogMessageString(MediaDeviceType device_type,
                                 const MediaDeviceInfoArray& device_infos) {
   std::string output_string =
       base::StringPrintf("Getting devices of type %d:\n", device_type);
   if (device_infos.empty())
     return output_string + "No devices found.";
   for (const auto& device_info : device_infos)
     output_string += "  " + device_info.label + "\n";
   return output_string;
 }
 
-MediaDeviceInfoArray EnumerateAudioDevicesOnDeviceThread(
-    media::AudioManager* audio_manager,
-    bool is_input) {
-  DCHECK(audio_manager->GetTaskRunner()->BelongsToCurrentThread());
-
-  MediaDeviceInfoArray snapshot;
-  media::AudioDeviceDescriptions device_descriptions;
-  if (is_input)
-    audio_manager->GetAudioInputDeviceDescriptions(&device_descriptions);
-  else
-    audio_manager->GetAudioOutputDeviceDescriptions(&device_descriptions);
-
-  for (const media::AudioDeviceDescription& description : device_descriptions)
-    snapshot.emplace_back(description);
-
-  return snapshot;
-}
-
 MediaDeviceInfoArray GetFakeAudioDevices(bool is_input) {
   MediaDeviceInfoArray result;
   if (is_input) {
     result.emplace_back(media::AudioDeviceDescription::kDefaultDeviceId,
                         "Fake Default Audio Input",
                         "fake_group_audio_input_default");
     result.emplace_back("fake_audio_input_1", "Fake Audio Input 1",
                         "fake_group_audio_input_1");
     result.emplace_back("fake_audio_input_2", "Fake Audio Input 2",
                         "fake_group_audio_input_2");
@@ skipping 77 matching lines @@
   }
 
   int64_t current_event_sequence_;
   int64_t seq_last_update_;
   int64_t seq_last_invalidation_;
   bool is_update_ongoing_;
   base::ThreadChecker thread_checker_;
 };
 
 MediaDevicesManager::MediaDevicesManager(
-    media::AudioManager* audio_manager,
+    media::AudioSystem* audio_system,
     const scoped_refptr<VideoCaptureManager>& video_capture_manager,
     MediaStreamManager* media_stream_manager)
     : use_fake_devices_(base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseFakeDeviceForMediaStream)),
-      audio_manager_(audio_manager),
+      audio_system_(audio_system),
       video_capture_manager_(video_capture_manager),
       media_stream_manager_(media_stream_manager),
       cache_infos_(NUM_MEDIA_DEVICE_TYPES),
       monitoring_started_(false),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(audio_manager_);
+  DCHECK(audio_system_);
   DCHECK(video_capture_manager_.get());
   cache_policies_.fill(CachePolicy::NO_CACHE);
   has_seen_result_.fill(false);
 }
 
 MediaDevicesManager::~MediaDevicesManager() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 void MediaDevicesManager::EnumerateDevices(
@@ skipping 92 matching lines @@
   BrowserMainLoop* browser_main_loop = content::BrowserMainLoop::GetInstance();
   if (!browser_main_loop)
     return;
 
   // TODO(erikchen): Remove ScopedTracker below once crbug.com/458404 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile2(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "458404 MediaDevicesManager::GetTaskRunner"));
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-      audio_manager_->GetTaskRunner();
+      audio_system_->GetTaskRunner();
   // TODO(erikchen): Remove ScopedTracker below once crbug.com/458404 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile3(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "458404 MediaDevicesManager::DeviceMonitorMac::StartMonitoring"));
   browser_main_loop->device_monitor_mac()->StartMonitoring(task_runner);
 }
 #endif
 
 void MediaDevicesManager::StopMonitoring() {
@@ skipping 62 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   MediaDeviceType type =
       is_input ? MEDIA_DEVICE_TYPE_AUDIO_INPUT : MEDIA_DEVICE_TYPE_AUDIO_OUTPUT;
   if (use_fake_devices_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&MediaDevicesManager::DevicesEnumerated,
                               weak_factory_.GetWeakPtr(), type,
                               GetFakeAudioDevices(is_input)));
     return;
   }
-  base::PostTaskAndReplyWithResult(
-      audio_manager_->GetTaskRunner(), FROM_HERE,
-      base::Bind(&EnumerateAudioDevicesOnDeviceThread, audio_manager_,
-                 is_input),
-      base::Bind(&MediaDevicesManager::DevicesEnumerated,
-                 weak_factory_.GetWeakPtr(), type));
+
+  audio_system_->GetDeviceDescriptions(
+      base::Bind(&MediaDevicesManager::AudioDevicesEnumerated,
+                 weak_factory_.GetWeakPtr(), type),
+      is_input);
 }
 
 void MediaDevicesManager::VideoInputDevicesEnumerated(
     const media::VideoCaptureDeviceDescriptors& descriptors) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   MediaDeviceInfoArray snapshot;
   for (const auto& descriptor : descriptors) {
     snapshot.emplace_back(descriptor);
   }
   DevicesEnumerated(MEDIA_DEVICE_TYPE_VIDEO_INPUT, snapshot);
 }
 
+void MediaDevicesManager::AudioDevicesEnumerated(
+    MediaDeviceType type,
+    media::AudioDeviceDescriptions device_descriptions) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  MediaDeviceInfoArray snapshot;
+  for (const media::AudioDeviceDescription& description : device_descriptions) {
+    snapshot.emplace_back(description);
+  }
+  DevicesEnumerated(type, snapshot);
+}
+
 void MediaDevicesManager::DevicesEnumerated(
     MediaDeviceType type,
     const MediaDeviceInfoArray& snapshot) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(IsValidMediaDeviceType(type));
   UpdateSnapshot(type, snapshot);
   cache_infos_[type].UpdateCompleted();
   has_seen_result_[type] = true;
 
   std::string log_message =
@@ skipping 116 matching lines @@
     const MediaDeviceInfoArray& snapshot) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(IsValidMediaDeviceType(type));
 
   for (auto* subscriber : device_change_subscribers_[type]) {
     subscriber->OnDevicesChanged(type, snapshot);
   }
 }
 
 }  // namespace content