Moving device description utils from AudioManager[Base] into AudioDeviceDescription; to be shared b…

media/audio/win/core_audio_util_win.cc

 // Copyright (c) 2012 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/win/core_audio_util_win.h"
 
 #include <devicetopology.h>
 #include <dxdiag.h>
 #include <functiondiscoverykeys_devpkey.h>
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_propvariant.h"
 #include "base/win/scoped_variant.h"
 #include "base/win/windows_version.h"
-#include "media/audio/audio_manager_base.h"
+#include "media/audio/audio_device_description.h"
 #include "media/base/media_switches.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedHandle;
 
 namespace media {
 
 // See header file for documentation.
 // {BE39AF4F-087C-423F-9303-234EC1E5B8EE}
 const GUID kCommunicationsSessionId = {
@@ skipping 109 matching lines @@
 
 static std::string GetDeviceID(IMMDevice* device) {
   ScopedCoMem<WCHAR> device_id_com;
   std::string device_id;
   if (SUCCEEDED(device->GetId(&device_id_com)))
     base::WideToUTF8(device_id_com, wcslen(device_id_com), &device_id);
   return device_id;
 }
 
 static bool IsDefaultDeviceId(const std::string& device_id) {
-  return device_id.empty() || device_id == AudioManagerBase::kDefaultDeviceId;
+  return device_id.empty() ||
+         device_id == AudioDeviceDescription::kDefaultDeviceId;
 }
 
 static bool IsDeviceActive(IMMDevice* device) {
   DWORD state = DEVICE_STATE_DISABLED;
   return SUCCEEDED(device->GetState(&state)) && (state & DEVICE_STATE_ACTIVE);
 }
 
 static HRESULT GetDeviceFriendlyNameInternal(IMMDevice* device,
                                              std::string* friendly_name) {
   // Retrieve user-friendly name of endpoint device.
@@ skipping 270 matching lines @@
     const std::string& input_device_id) {
   // Special handling for the default communications device.
   // We always treat the configured communications devices, as a pair.
   // If we didn't do that and the user has e.g. configured a mic of a headset
   // as the default comms input device and a different device (not the speakers
   // of the headset) as the default comms output device, then we would otherwise
   // here pick the headset as the matched output device.  That's technically
   // correct, but the user experience would be that any audio played out to
   // the matched device, would get ducked since it's not the default comms
   // device.  So here, we go with the user's configuration.
-  if (input_device_id == AudioManagerBase::kCommunicationsDeviceId)
-    return AudioManagerBase::kCommunicationsDeviceId;
+  if (input_device_id == AudioDeviceDescription::kCommunicationsDeviceId)
+    return AudioDeviceDescription::kCommunicationsDeviceId;
 
   ScopedComPtr<IMMDevice> input_device;
   if (IsDefaultDeviceId(input_device_id)) {
     input_device = CreateDefaultDevice(eCapture, eConsole);
   } else {
     input_device = CreateDevice(input_device_id);
   }
 
   if (!input_device.get())
     return std::string();
@@ skipping 281 matching lines @@
   *params = audio_params;
   return hr;
 }
 
 HRESULT CoreAudioUtil::GetPreferredAudioParameters(const std::string& device_id,
                                                    bool is_output_device,
                                                    AudioParameters* params) {
   DCHECK(IsSupported());
 
   ScopedComPtr<IMMDevice> device;
-  if (device_id == AudioManagerBase::kDefaultDeviceId) {
+  if (device_id == AudioDeviceDescription::kDefaultDeviceId) {
     device = CoreAudioUtil::CreateDefaultDevice(
         is_output_device ? eRender : eCapture, eConsole);
-  } else if (device_id == AudioManagerBase::kLoopbackInputDeviceId) {
+  } else if (device_id == AudioDeviceDescription::kLoopbackInputDeviceId) {
     DCHECK(!is_output_device);
     device = CoreAudioUtil::CreateDefaultDevice(eRender, eConsole);
-  } else if (device_id == AudioManagerBase::kCommunicationsDeviceId) {
+  } else if (device_id == AudioDeviceDescription::kCommunicationsDeviceId) {
     device = CoreAudioUtil::CreateDefaultDevice(
         is_output_device ? eRender : eCapture, eCommunications);
   } else {
     device = CreateDevice(device_id);
   }
 
   if (!device.get()) {
     // Map NULL-pointer to new error code which can be different from the
     // actual error code. The exact value is not important here.
     return AUDCLNT_E_DEVICE_INVALIDATED;
@@ skipping 200 matching lines @@
 
   if (variant.type() == VT_BSTR && variant.ptr()->bstrVal) {
     base::WideToUTF8(variant.ptr()->bstrVal, wcslen(variant.ptr()->bstrVal),
                      driver_version);
   }
 
   return true;
 }
 
 }  // namespace media