Switching MediaStreamsManager from using AudioManager interface to AudioSystem one.

content/browser/renderer_host/media/media_devices_manager.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_DEVICES_MANAGER_H_
 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_DEVICES_MANAGER_H_
 
 #include <array>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/system_monitor/system_monitor.h"
 #include "content/common/content_export.h"
 #include "content/common/media/media_devices.h"
+#include "media/audio/audio_device_description.h"
 #include "media/capture/video/video_capture_device_descriptor.h"
 
 namespace media {
-class AudioManager;
+class AudioSystem;
 }
 
 namespace content {
 
 class MediaStreamManager;
 class VideoCaptureManager;
 
 // Use MediaDeviceType values to index on this type.
 using MediaDeviceEnumeration =
     std::array<MediaDeviceInfoArray, NUM_MEDIA_DEVICE_TYPES>;
@@ skipping 22 matching lines @@
   class BoolDeviceTypes final
       : public std::array<bool, NUM_MEDIA_DEVICE_TYPES> {
    public:
     BoolDeviceTypes() { fill(false); }
   };
 
   using EnumerationCallback =
       base::Callback<void(const MediaDeviceEnumeration&)>;
 
   MediaDevicesManager(
-      media::AudioManager* audio_manager,
+      media::AudioSystem* audio_system,
       const scoped_refptr<VideoCaptureManager>& video_capture_manager,
       MediaStreamManager* media_stream_manager);
   ~MediaDevicesManager() override;
 
   // Performs a possibly cached device enumeration for the requested device
   // types and reports the results to |callback|.
   // The enumeration results passed to |callback| are guaranteed to be valid
   // only for the types specified in |requested_types|.
   // Note that this function is not reentrant, so if |callback| needs to perform
   // another call to EnumerateDevices, it must do so by posting a task to the
@@ skipping 56 matching lines @@
   void SetCachePolicy(MediaDeviceType type, CachePolicy policy);
 
   // Helpers to issue low-level device enumerations.
   void DoEnumerateDevices(MediaDeviceType type);
   void EnumerateAudioDevices(bool is_input);
 
   // Callback for VideoCaptureManager::EnumerateDevices.
   void VideoInputDevicesEnumerated(
       const media::VideoCaptureDeviceDescriptors& descriptors);
 
+  // Callback for AudioSystem::GetDeviceDescriptions.
+  void AudioDevicesEnumerated(
+      MediaDeviceType type,
+      media::AudioDeviceDescriptions device_descriptions);
+
   // Helpers to handle enumeration results.
   void DevicesEnumerated(MediaDeviceType type,
                          const MediaDeviceInfoArray& snapshot);
   void UpdateSnapshot(MediaDeviceType type,
                       const MediaDeviceInfoArray& new_snapshot);
   void ProcessRequests();
   bool IsEnumerationRequestReady(const EnumerationRequest& request_info);
 
   // Helpers to handle device-change notification.
   void HandleDevicesChanged(MediaDeviceType type);
   void NotifyMediaStreamManager(MediaDeviceType type,
                                 const MediaDeviceInfoArray& new_snapshot);
   void NotifyDeviceChangeSubscribers(MediaDeviceType type,
                                      const MediaDeviceInfoArray& snapshot);
 
 #if defined(OS_MACOSX)
   void StartMonitoringOnUIThread();
 #endif
 
   bool use_fake_devices_;
-  media::AudioManager* const audio_manager_;  // not owned
+  media::AudioSystem* const audio_system_;  // not owned
   scoped_refptr<VideoCaptureManager> video_capture_manager_;
   MediaStreamManager* const media_stream_manager_;  // not owned
 
   using CachePolicies = std::array<CachePolicy, NUM_MEDIA_DEVICE_TYPES>;
   CachePolicies cache_policies_;
 
   class CacheInfo;
   using CacheInfos = std::vector<CacheInfo>;
   CacheInfos cache_infos_;
 
   BoolDeviceTypes has_seen_result_;
   std::vector<EnumerationRequest> requests_;
   MediaDeviceEnumeration current_snapshot_;
   bool monitoring_started_;
 
   std::vector<MediaDeviceChangeSubscriber*>
       device_change_subscribers_[NUM_MEDIA_DEVICE_TYPES];
 
   base::WeakPtrFactory<MediaDevicesManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaDevicesManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_DEVICES_MANAGER_H_