Remove the wave based audio capture implementation for Windows

media/audio/win/audio_manager_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/audio_manager_win.h"
 
 #include <windows.h>
 #include <objbase.h>  // This has to be before initguid.h
 #include <initguid.h>
 #include <mmsystem.h>
@@ skipping 13 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/win/windows_version.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/win/audio_device_listener_win.h"
 #include "media/audio/win/audio_low_latency_input_win.h"
 #include "media/audio/win/audio_low_latency_output_win.h"
 #include "media/audio/win/core_audio_util_win.h"
 #include "media/audio/win/device_enumeration_win.h"
-#include "media/audio/win/wavein_input_win.h"
 #include "media/audio/win/waveout_output_win.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/channel_layout.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 
 // The following are defined in various DDK headers, and we (re)define them here
 // to avoid adding the DDK as a chrome dependency.
 #define DRV_QUERYDEVICEINTERFACE 0x80c
 #define DRVM_MAPPER_PREFERRED_GET 0x2015
 #define DRV_QUERYDEVICEINTERFACESIZE 0x80d
-DEFINE_GUID(AM_KSCATEGORY_AUDIO, 0x6994ad04, 0x93ef, 0x11d0,
-            0xa3, 0xcc, 0x00, 0xa0, 0xc9, 0x22, 0x31, 0x96);
+DEFINE_GUID(AM_KSCATEGORY_AUDIO,

[tommi (sloooow) - chröme, 2017/01/24 21:10:51]

some changes, like this one, are due to git cl format.

+            0x6994ad04,
+            0x93ef,
+            0x11d0,
+            0xa3,
+            0xcc,
+            0x00,
+            0xa0,
+            0xc9,
+            0x22,
+            0x31,
+            0x96);
 
 namespace media {
 
 // Maximum number of output streams that can be open simultaneously.
 static const int kMaxOutputStreams = 50;
 
 // Up to 8 channels can be passed to the driver.  This should work, given the
 // right drivers, but graceful error handling is needed.
 static const int kWinMaxChannels = 8;
 
-// We use 3 buffers for recording audio so that if a recording callback takes
-// some time to return we won't lose audio. More buffers while recording are
-// ok because they don't introduce any delay in recording, unlike in playback
-// where you first need to fill in that number of buffers before starting to
-// play.
-static const int kNumInputBuffers = 3;
-
 // Buffer size to use for input and output stream when a proper size can't be
 // determined from the system
 static const int kFallbackBufferSize = 2048;
 
 static int GetVersionPartAsInt(DWORDLONG num) {
   return static_cast<int>(num & 0xffff);
 }
 
 // Returns a string containing the given device's description and installed
 // driver version.
@@ skipping 11 matching lines @@
                                 &device_install_params);
 
   SP_DRVINFO_DATA driver_data;
   driver_data.cbSize = sizeof(driver_data);
   base::string16 device_and_driver_info;
   if (SetupDiBuildDriverInfoList(device_info, device_data,
                                  SPDIT_COMPATDRIVER)) {
     if (SetupDiEnumDriverInfo(device_info, device_data, SPDIT_COMPATDRIVER, 0,
                               &driver_data)) {
       DWORDLONG version = driver_data.DriverVersion;
-      device_and_driver_info = base::string16(driver_data.Description) + L" v" +
+      device_and_driver_info =
+          base::string16(driver_data.Description) + L" v" +
           base::IntToString16(GetVersionPartAsInt((version >> 48))) + L"." +
           base::IntToString16(GetVersionPartAsInt((version >> 32))) + L"." +
           base::IntToString16(GetVersionPartAsInt((version >> 16))) + L"." +
           base::IntToString16(GetVersionPartAsInt(version));
     }
     SetupDiDestroyDriverInfoList(device_info, device_data, SPDIT_COMPATDRIVER);
   }
 
   SetupDiSetDeviceInstallParams(device_info, device_data,
                                 &old_device_install_params);
@@ skipping 19 matching lines @@
   //  - Some XP configurations (even multi-processor ones) also need 3.
   return (base::win::GetVersion() == base::win::VERSION_VISTA) ? 4 : 3;
 }
 
 AudioManagerWin::AudioManagerWin(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
     AudioLogFactory* audio_log_factory)
     : AudioManagerBase(std::move(task_runner),
                        std::move(worker_task_runner),
-                       audio_log_factory),
-      // |CoreAudioUtil::IsSupported()| uses static variables to avoid doing
-      // multiple initializations.  This is however not thread safe.
-      // So, here we call it explicitly before we kick off the audio thread
-      // or do any other work.
-      enumeration_type_(CoreAudioUtil::IsSupported() ? kMMDeviceEnumeration

[DaleCurtis, 2017/01/24 21:09:30]

This may be a race now in the setup of the internals for
CoreAudioUtil::IsSupported(). Possibly it doesn't matter, but we may want to
change that to a lazy_instance.

[tommi (sloooow) - chröme, 2017/01/24 21:34:57]

Ah, thanks for pointing that out. I had forgotten that Win7 actually had issues
there as well (wonder the status of that now, almost 4 years later).
What do you think about keeping this comment, move it into the ctor body and
call IsSupported directly?  Henrik has a good point about the wave API being
built on top of CoreAudio so I think that if CoreAudio itself doesn't work,
there may not be much we can do and the methods for creating audio streams, will
fail, but at least we can attempt to make them.

[DaleCurtis, 2017/01/24 21:47:26]

I think that's the safest change for now. It'd be nice if we could leave this on
the audio thread, but I think you had to move it here to fix races with other
code (possibly the device enumeration code now being removed, hopefully)

-                                                     : kWaveEnumeration) {
+                       audio_log_factory) {
   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 
   // WARNING: This is executed on the UI loop, do not add any code here which
   // loads libraries or attempts to call out into the OS.  Instead add such code
   // to the InitializeOnAudioThread() method below.
 
   // Task must be posted last to avoid races from handing out "this" to the
   // audio thread.
-  GetTaskRunner()->PostTask(FROM_HERE, base::Bind(
-      &AudioManagerWin::InitializeOnAudioThread, base::Unretained(this)));
+  GetTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&AudioManagerWin::InitializeOnAudioThread,
+                            base::Unretained(this)));
 }
 
 AudioManagerWin::~AudioManagerWin() {
   Shutdown();
 }
 
 bool AudioManagerWin::HasAudioOutputDevices() {
   return (::waveOutGetNumDevs() != 0);
 }
 
 bool AudioManagerWin::HasAudioInputDevices() {
   return (::waveInGetNumDevs() != 0);
 }
 
 void AudioManagerWin::InitializeOnAudioThread() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
-  if (core_audio_supported()) {
-    // AudioDeviceListenerWin must be initialized on a COM thread and should
-    // only be used if WASAPI / Core Audio is supported.
-    output_device_listener_.reset(new AudioDeviceListenerWin(BindToCurrentLoop(
-        base::Bind(&AudioManagerWin::NotifyAllOutputDeviceChangeListeners,
-                   base::Unretained(this)))));
-  }
+  // AudioDeviceListenerWin must be initialized on a COM thread.
+  output_device_listener_.reset(new AudioDeviceListenerWin(BindToCurrentLoop(
+      base::Bind(&AudioManagerWin::NotifyAllOutputDeviceChangeListeners,
+                 base::Unretained(this)))));
 }
 
 base::string16 AudioManagerWin::GetAudioInputDeviceModel() {

[henrika (OOO until Aug 14), 2017/01/25 12:43:33]

Used at
https://cs.chromium.org/chromium/src/content/browser/speech/speech_recognitio...
but not sure if it is actually needed?

[tommi (sloooow) - chröme, 2017/01/25 21:44:33]

It's not needed now that Olga has landed her patch to remove the dependency in
content.  I'll remove it in a separate cl.

   // Get the default audio capture device and its device interface name.
   DWORD device_id = 0;
   waveInMessage(reinterpret_cast<HWAVEIN>(WAVE_MAPPER),
                 DRVM_MAPPER_PREFERRED_GET,
                 reinterpret_cast<DWORD_PTR>(&device_id), NULL);
   ULONG device_interface_name_size = 0;
   waveInMessage(reinterpret_cast<HWAVEIN>(device_id),
                 DRV_QUERYDEVICEINTERFACESIZE,
                 reinterpret_cast<DWORD_PTR>(&device_interface_name_size), 0);
   size_t bytes_in_char16 = sizeof(base::string16::value_type);
   DCHECK_EQ(0u, device_interface_name_size % bytes_in_char16);
   if (device_interface_name_size <= bytes_in_char16)
     return base::string16();  // No audio capture device.
 
   base::string16 device_interface_name;
-  base::string16::value_type* name_ptr = base::WriteInto(&device_interface_name,
-      device_interface_name_size / bytes_in_char16);
-  waveInMessage(reinterpret_cast<HWAVEIN>(device_id),
-                DRV_QUERYDEVICEINTERFACE,
+  base::string16::value_type* name_ptr = base::WriteInto(
+      &device_interface_name, device_interface_name_size / bytes_in_char16);
+  waveInMessage(reinterpret_cast<HWAVEIN>(device_id), DRV_QUERYDEVICEINTERFACE,
                 reinterpret_cast<DWORD_PTR>(name_ptr),
                 static_cast<DWORD_PTR>(device_interface_name_size));
 
   // Enumerate all audio devices and find the one matching the above device
   // interface name.
   HDEVINFO device_info = SetupDiGetClassDevs(
       &AM_KSCATEGORY_AUDIO, 0, 0, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
   if (device_info == INVALID_HANDLE_VALUE)
     return base::string16();
 
@@ skipping 10 matching lines @@
                                     &interface_detail_size, &device_data);
     if (!interface_detail_size)
       continue;
 
     std::unique_ptr<char[]> interface_detail_buffer(
         new char[interface_detail_size]);
     SP_DEVICE_INTERFACE_DETAIL_DATA* interface_detail =
         reinterpret_cast<SP_DEVICE_INTERFACE_DETAIL_DATA*>(
             interface_detail_buffer.get());
     interface_detail->cbSize = interface_detail_size;
-    if (!SetupDiGetDeviceInterfaceDetail(device_info, &interface_data,
-                                         interface_detail,
-                                         interface_detail_size, NULL,
-                                         &device_data))
+    if (!SetupDiGetDeviceInterfaceDetail(
+            device_info, &interface_data, interface_detail,
+            interface_detail_size, NULL, &device_data))
       return base::string16();
 
     bool device_found = (device_interface_name == interface_detail->DevicePath);
 
     if (device_found)
       return GetDeviceAndDriverInfo(device_info, &device_data);
   }
 
   return base::string16();
 }
 
 void AudioManagerWin::ShowAudioInputSettings() {
-  std::wstring program;
-  std::string argument;
-  if (!core_audio_supported()) {
-    program = L"sndvol32.exe";
-    argument = "-R";
-  } else {
-    program = L"control.exe";
-    argument = "mmsys.cpl,,1";
-  }
-
   base::FilePath path;
   PathService::Get(base::DIR_SYSTEM, &path);
-  path = path.Append(program);
+  path = path.Append(L"control.exe");
   base::CommandLine command_line(path);
-  command_line.AppendArg(argument);
+  command_line.AppendArg("mmsys.cpl,,1");
   base::LaunchProcess(command_line, base::LaunchOptions());
 }
 
-void AudioManagerWin::GetAudioDeviceNamesImpl(
-    bool input,
-    AudioDeviceNames* device_names) {
+void AudioManagerWin::GetAudioDeviceNamesImpl(bool input,
+                                              AudioDeviceNames* device_names) {
   DCHECK(device_names->empty());
   // Enumerate all active audio-endpoint capture devices.
-  if (enumeration_type() == kWaveEnumeration) {
-    // Utilize the Wave API for Windows XP.
-    if (input)
-      GetInputDeviceNamesWinXP(device_names);
-    else
-      GetOutputDeviceNamesWinXP(device_names);
-  } else {
-    // Utilize the MMDevice API (part of Core Audio) for Vista and higher.
-    if (input)
-      GetInputDeviceNamesWin(device_names);
-    else
-      GetOutputDeviceNamesWin(device_names);
-  }
+  if (input)
+    GetInputDeviceNamesWin(device_names);
+  else
+    GetOutputDeviceNamesWin(device_names);
 
   if (!device_names->empty()) {
-    if (enumeration_type() == kMMDeviceEnumeration)
-      device_names->push_front(AudioDeviceName::CreateCommunications());
+    device_names->push_front(AudioDeviceName::CreateCommunications());
 
     // Always add default device parameters as first element.
     device_names->push_front(AudioDeviceName::CreateDefault());
   }
 }
 
 void AudioManagerWin::GetAudioInputDeviceNames(AudioDeviceNames* device_names) {
   GetAudioDeviceNamesImpl(true, device_names);
 }
 
 void AudioManagerWin::GetAudioOutputDeviceNames(
     AudioDeviceNames* device_names) {
   GetAudioDeviceNamesImpl(false, device_names);
 }
 
 AudioParameters AudioManagerWin::GetInputStreamParameters(
     const std::string& device_id) {
-  HRESULT hr = E_FAIL;
   AudioParameters parameters;
-  if (core_audio_supported()) {
-    hr = CoreAudioUtil::GetPreferredAudioParameters(device_id, false,
-                                                    &parameters);
-  }
+  HRESULT hr =
+      CoreAudioUtil::GetPreferredAudioParameters(device_id, false, &parameters);

[DaleCurtis, 2017/01/24 21:09:30]

This method will DCHECK() IsSupported(). I don't fully understand all the
failure cases there, but if the DLLs or anything are missing we might get
crashes instead of graceful failure. See l.219 in the CoreAudioUtil code.

[tommi (sloooow) - chröme, 2017/01/24 21:34:56]

I read over the bug, refreshing my memory.  In the cases of missing DLLs, we'll
get an error reported back (The specified module could not be found)

[DaleCurtis, 2017/01/24 21:47:26]

sgtm

 
   if (FAILED(hr) || !parameters.IsValid()) {
-    // Windows Wave implementation is being used.
+    // Fall back on default parameters.
+    // TODO(tommi): Is this necessary? I'd guess that things would go wrong
+    // elsewhere if we weren't able to get the preferred audio parameters.

[tommi (sloooow) - chröme, 2017/01/24 21:10:51]

Should we remove this block and return invalid audio parameters if this happens?
Maybe add a UMA stat?

[DaleCurtis, 2017/01/24 21:47:25]

That sgtm, there's not point anymore.

[henrika (OOO until Aug 14), 2017/01/25 12:43:33]

sgtm

[tommi (sloooow) - chröme, 2017/01/25 12:49:25]

Done. (just return if we failed or params aren't valid)

     parameters =
         AudioParameters(AudioParameters::AUDIO_PCM_LINEAR,
                         CHANNEL_LAYOUT_STEREO, 48000, 16, kFallbackBufferSize);
   }
 
   int user_buffer_size = GetUserBufferSize();
   if (user_buffer_size)
     parameters.set_frames_per_buffer(user_buffer_size);
 
   return parameters;
 }
 
 std::string AudioManagerWin::GetAssociatedOutputDeviceID(
     const std::string& input_device_id) {
-  if (!core_audio_supported()) {
-    NOTIMPLEMENTED()
-        << "GetAssociatedOutputDeviceID is not supported on this OS";
-    return std::string();
-  }
   return CoreAudioUtil::GetMatchingOutputDeviceID(input_device_id);
 }
 
 const char* AudioManagerWin::GetName() {
   return "Windows";
 }
 
 // Factory for the implementations of AudioOutputStream for AUDIO_PCM_LINEAR
 // mode.
 // - PCMWaveOutAudioOutputStream: Based on the waveOut API.
 AudioOutputStream* AudioManagerWin::MakeLinearOutputStream(
     const AudioParameters& params,
     const LogCallback& log_callback) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
   if (params.channels() > kWinMaxChannels)
     return NULL;
 
-  return new PCMWaveOutAudioOutputStream(this,
-                                         params,
-                                         NumberOfWaveOutBuffers(),
+  return new PCMWaveOutAudioOutputStream(this, params, NumberOfWaveOutBuffers(),
                                          WAVE_MAPPER);
 }
 
 // Factory for the implementations of AudioOutputStream for
 // AUDIO_PCM_LOW_LATENCY mode. Two implementations should suffice most
 // windows user's needs.
 // - PCMWaveOutAudioOutputStream: Based on the waveOut API.
 // - WASAPIAudioOutputStream: Based on Core Audio (WASAPI) API.
 AudioOutputStream* AudioManagerWin::MakeLowLatencyOutputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const LogCallback& log_callback) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   if (params.channels() > kWinMaxChannels)
     return NULL;
 
-  if (!core_audio_supported()) {
-    // Fall back to Windows Wave implementation on Windows XP or lower.
-    DLOG_IF(ERROR, !device_id.empty() &&
-                       device_id != AudioDeviceDescription::kDefaultDeviceId)
-        << "Opening by device id not supported by PCMWaveOutAudioOutputStream";
-    DVLOG(1) << "Using WaveOut since WASAPI requires at least Vista.";
-    return new PCMWaveOutAudioOutputStream(
-        this, params, NumberOfWaveOutBuffers(), WAVE_MAPPER);
-  }
-
   // Pass an empty string to indicate that we want the default device
   // since we consistently only check for an empty string in
   // WASAPIAudioOutputStream.
   bool communications =
       device_id == AudioDeviceDescription::kCommunicationsDeviceId;
   return new WASAPIAudioOutputStream(
       this,
       communications || device_id == AudioDeviceDescription::kDefaultDeviceId
           ? std::string()
           : device_id,
       params, communications ? eCommunications : eConsole);
 }
 
 // Factory for the implementations of AudioInputStream for AUDIO_PCM_LINEAR
 // mode.
 AudioInputStream* AudioManagerWin::MakeLinearInputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const LogCallback& log_callback) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
-  return CreatePCMWaveInAudioInputStream(params, device_id);
+  return MakeLowLatencyInputStream(params, device_id, log_callback);
 }
 
 // Factory for the implementations of AudioInputStream for
 // AUDIO_PCM_LOW_LATENCY mode.
 AudioInputStream* AudioManagerWin::MakeLowLatencyInputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const LogCallback& log_callback) {
-  DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
+  // Used for both AUDIO_PCM_LOW_LATENCY and AUDIO_PCM_LINEAR.
   DVLOG(1) << "MakeLowLatencyInputStream: " << device_id;
-  AudioInputStream* stream = NULL;
-  UMA_HISTOGRAM_BOOLEAN("Media.WindowsCoreAudioInput", core_audio_supported());
-  if (!core_audio_supported()) {
-    // Fall back to Windows Wave implementation on Windows XP or lower.
-    DVLOG(1) << "Using WaveIn since WASAPI requires at least Vista.";
-    stream = CreatePCMWaveInAudioInputStream(params, device_id);
-  } else {
-    stream = new WASAPIAudioInputStream(this, params, device_id);
-  }
-
-  return stream;
+  return new WASAPIAudioInputStream(this, params, device_id);
 }
 
 std::string AudioManagerWin::GetDefaultOutputDeviceID() {
-  if (!core_audio_supported())
-    return std::string();
   return CoreAudioUtil::GetDefaultOutputDeviceID();
 }
 
 AudioParameters AudioManagerWin::GetPreferredOutputStreamParameters(
     const std::string& output_device_id,
     const AudioParameters& input_params) {
-  DLOG_IF(ERROR, !core_audio_supported() && !output_device_id.empty())
-      << "CoreAudio is required to open non-default devices.";
-
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   int sample_rate = 48000;
   int buffer_size = kFallbackBufferSize;
   int bits_per_sample = 16;
   int effects = AudioParameters::NO_EFFECTS;
-  bool use_input_params = !core_audio_supported();
-  if (core_audio_supported()) {
-    if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio)) {
-      // TODO(rtoy): tune these values for best possible WebAudio
-      // performance. WebRTC works well at 48kHz and a buffer size of 480
-      // samples will be used for this case. Note that exclusive mode is
-      // experimental. This sample rate will be combined with a buffer size of
-      // 256 samples, which corresponds to an output delay of ~5.33ms.
-      sample_rate = 48000;
-      buffer_size = 256;
-      if (input_params.IsValid())
-        channel_layout = input_params.channel_layout();
+  bool use_input_params = false;
+  if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio)) {

[DaleCurtis, 2017/01/24 21:09:30]

Hmm, I wonder if we should remove the exclusive audio support too. Is anyone
using it?

[tommi (sloooow) - chröme, 2017/01/24 21:34:56]

Good question. Perhaps we could add a counter for that.  I doubt its being used
much but the reason for it existing, is to be able to lower latency.

[DaleCurtis, 2017/01/24 21:47:26]

If crashes are any indication, there are 9 reports for all time :p

https://crash.corp.google.com/browse?q=product.name%3D%27Chrome%27%20OMIT%20R...

[henrika (OOO until Aug 14), 2017/01/25 12:43:33]

Smart to check crashes Dale ;-)

I added the support a long time ago but since it was not possible to do the same
on input, the actual usage seems very, very limited.

Perhaps remove in a separate CL to make it more clear.

[tommi (sloooow) - chröme, 2017/01/25 12:49:25]

Added TODO for henrik to remove the switch and associated code.

+    // TODO(rtoy): tune these values for best possible WebAudio
+    // performance. WebRTC works well at 48kHz and a buffer size of 480
+    // samples will be used for this case. Note that exclusive mode is
+    // experimental. This sample rate will be combined with a buffer size of
+    // 256 samples, which corresponds to an output delay of ~5.33ms.
+    sample_rate = 48000;
+    buffer_size = 256;
+    if (input_params.IsValid())
+      channel_layout = input_params.channel_layout();
+  } else {
+    AudioParameters params;
+    HRESULT hr = CoreAudioUtil::GetPreferredAudioParameters(
+        output_device_id.empty() ? GetDefaultOutputDeviceID()
+                                 : output_device_id,
+        true, &params);
+    if (SUCCEEDED(hr)) {
+      bits_per_sample = params.bits_per_sample();
+      buffer_size = params.frames_per_buffer();
+      channel_layout = params.channel_layout();
+      sample_rate = params.sample_rate();
+      effects = params.effects();
     } else {
-      AudioParameters params;
-      HRESULT hr = CoreAudioUtil::GetPreferredAudioParameters(
-          output_device_id.empty() ? GetDefaultOutputDeviceID()
-                                   : output_device_id,
-          true, &params);
-      if (SUCCEEDED(hr)) {
-        bits_per_sample = params.bits_per_sample();
-        buffer_size = params.frames_per_buffer();
-        channel_layout = params.channel_layout();
-        sample_rate = params.sample_rate();
-        effects = params.effects();
-      } else {
-        // TODO(tommi): This should never happen really and I'm not sure that
-        // setting use_input_params is the right thing to do since WASAPI i
-        // definitely supported (see  core_audio_supported() above) and
-        // |use_input_params| is only for cases when it isn't supported.
-        DLOG(ERROR) << "GetPreferredAudioParameters failed: " << std::hex << hr;
-        use_input_params = true;
-      }
+      // TODO(tommi): This should never happen really and I'm not sure that
+      // setting use_input_params is the right thing to do since WASAPI i
+      // definitely supported (see  core_audio_supported() above) and
+      // |use_input_params| is only for cases when it isn't supported.
+      DLOG(ERROR) << "GetPreferredAudioParameters failed: " << std::hex << hr;
+      use_input_params = true;

[tommi (sloooow) - chröme, 2017/01/24 21:10:51]

this is another thing that I think we may have unnecessary complexity.  I could
remove this part and the use_input_params variable.

[DaleCurtis, 2017/01/24 21:47:26]

Since we're keeping WaveOut I think we still need this. Possibly this whole
thing could be vastly simplified though to just always return input params if
failure.

[tommi (sloooow) - chröme, 2017/01/25 12:49:25]

Makes sense. Looking at the case where input_params are invalid and we fail to
get the preferred audio params, we may actually return valid audio parameters
back.  Looks like a bug to me and I wonder if we're doing ourselves a favour or
creating problems by initializing the variables above, such as sample_rate, with
a valid sample rate, without knowing anything about the device...

[henrika (OOO until Aug 14), 2017/01/25 12:59:42]

I kind of have the same feeling. It would probably be better to receive reports
where a clear failure happened rather than figuring out that some default
setting was used instead under very special circumstances. As you say, we don't
know anything about the device.

     }
   }
 
   if (input_params.IsValid()) {
     // If the user has enabled checking supported channel layouts or we don't
     // have a valid channel layout yet, try to use the input layout.  See bugs
     // http://crbug.com/259165 and http://crbug.com/311906 for more details.
-    if (core_audio_supported() &&
-        (cmd_line->HasSwitch(switches::kTrySupportedChannelLayouts) ||
-         channel_layout == CHANNEL_LAYOUT_UNSUPPORTED)) {
+    if (cmd_line->HasSwitch(switches::kTrySupportedChannelLayouts) ||
+        channel_layout == CHANNEL_LAYOUT_UNSUPPORTED) {
       // Check if it is possible to open up at the specified input channel
       // layout but avoid checking if the specified layout is the same as the
       // hardware (preferred) layout. We do this extra check to avoid the
       // CoreAudioUtil::IsChannelLayoutSupported() overhead in most cases.
       if (input_params.channel_layout() != channel_layout) {
         // TODO(henrika): Internally, IsChannelLayoutSupported does many of the
         // operations that have already been done such as opening up a client
         // and fetching the WAVEFORMATPCMEX format.  Ideally we should only do
         // that once.  Then here, we can check the layout from the data we
         // already hold.
@@ skipping 26 matching lines @@
   int user_buffer_size = GetUserBufferSize();
   if (user_buffer_size)
     buffer_size = user_buffer_size;
 
   AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
                          sample_rate, bits_per_sample, buffer_size);
   params.set_effects(effects);
   return params;
 }
 
-AudioInputStream* AudioManagerWin::CreatePCMWaveInAudioInputStream(
-    const AudioParameters& params,
-    const std::string& device_id) {
-  std::string xp_device_id = device_id;
-  if (device_id != AudioDeviceDescription::kDefaultDeviceId &&
-      enumeration_type_ == kMMDeviceEnumeration) {
-    xp_device_id = ConvertToWinXPInputDeviceId(device_id);
-    if (xp_device_id.empty()) {
-      DLOG(ERROR) << "Cannot find a waveIn device which matches the device ID "
-                  << device_id;
-      return NULL;
-    }
-  }
-
-  return new PCMWaveInAudioInputStream(this, params, kNumInputBuffers,
-                                       xp_device_id);
-}
-
-/// static
+// static
 ScopedAudioManagerPtr CreateAudioManager(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
     AudioLogFactory* audio_log_factory) {
   return ScopedAudioManagerPtr(
       new AudioManagerWin(std::move(task_runner), std::move(worker_task_runner),
                           audio_log_factory));
 }
 
 }  // namespace media