Revert of Remove the last piece of deprecated synchronous IO code.

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/audio_io.h"
 
 #include <windows.h>
 #include <objbase.h>  // This has to be before initguid.h
 #include <initguid.h>
 #include <mmsystem.h>
@@ skipping 287 matching lines @@
     AudioDeviceNames* device_names) {
   GetAudioDeviceNamesImpl(false, device_names);
 }
 
 AudioParameters AudioManagerWin::GetInputStreamParameters(
     const std::string& device_id) {
   AudioParameters parameters;
   if (!core_audio_supported()) {
     // Windows Wave implementation is being used.
     parameters = AudioParameters(
-        AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO, 48000,
+        AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO, 0, 48000,
         16, kFallbackBufferSize, AudioParameters::NO_EFFECTS);
   } else  {
     parameters = WASAPIAudioInputStream::GetInputStreamParameters(device_id);
   }
 
   int user_buffer_size = GetUserBufferSize();
   if (user_buffer_size) {
     parameters.Reset(parameters.format(), parameters.channel_layout(),
-                     parameters.channels(), parameters.sample_rate(),
-                     parameters.bits_per_sample(), user_buffer_size);
+                     parameters.channels(), parameters.input_channels(),
+                     parameters.sample_rate(), parameters.bits_per_sample(),
+                     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";
@@ skipping 85 matching lines @@
     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 CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   int sample_rate = 48000;
   int buffer_size = kFallbackBufferSize;
   int bits_per_sample = 16;
+  int input_channels = 0;
   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;
@@ skipping 44 matching lines @@
                 output_device_id, eRender, eConsole,
                 input_params.channel_layout())) {
           // Open up using the same channel layout as the source if it is
           // supported by the hardware.
           channel_layout = input_params.channel_layout();
           VLOG(1) << "Hardware channel layout is not used; using same layout"
                   << " as the source instead (" << channel_layout << ")";
         }
       }
     }
-
+    input_channels = input_params.input_channels();
     effects |= input_params.effects();
     if (use_input_params) {
       // If WASAPI isn't supported we'll fallback to WaveOut, which will take
       // care of resampling and bits per sample changes.  By setting these
       // equal to the input values, AudioOutputResampler will skip resampling
       // and bit per sample differences (since the input parameters will match
       // the output parameters).
       bits_per_sample = input_params.bits_per_sample();
       buffer_size = input_params.frames_per_buffer();
       channel_layout = input_params.channel_layout();
       sample_rate = input_params.sample_rate();
     }
   }
 
   int user_buffer_size = GetUserBufferSize();
   if (user_buffer_size)
     buffer_size = user_buffer_size;
 
   return AudioParameters(
-      AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
+      AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, input_channels,
       sample_rate, bits_per_sample, buffer_size, effects);
 }
 
 AudioInputStream* AudioManagerWin::CreatePCMWaveInAudioInputStream(
     const AudioParameters& params,
     const std::string& device_id) {
   std::string xp_device_id = device_id;
   if (device_id != AudioManagerBase::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
 AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory) {
   return new AudioManagerWin(audio_log_factory);
 }
 
 }  // namespace media