Wire up the output device id and provide an implementation on Windows.

media/audio/audio_output_resampler.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_output_resampler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 129 matching lines @@
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LINEAR, input_params.channel_layout(),
       input_params.sample_rate(), input_params.bits_per_sample(),
       frames_per_buffer);
 }
 #endif
 
 AudioOutputResampler::AudioOutputResampler(AudioManager* audio_manager,
                                            const AudioParameters& input_params,
                                            const AudioParameters& output_params,
+                                           const std::string& output_device_id,
                                            const std::string& input_device_id,
                                            const base::TimeDelta& close_delay)
-    : AudioOutputDispatcher(audio_manager, input_params, input_device_id),
+    : AudioOutputDispatcher(audio_manager, input_params, output_device_id,
+                            input_device_id),
       close_delay_(close_delay),
       output_params_(output_params),
-      input_device_id_(input_device_id),
       streams_opened_(false) {
   DCHECK(input_params.IsValid());
   DCHECK(output_params.IsValid());
   DCHECK_EQ(output_params_.format(), AudioParameters::AUDIO_PCM_LOW_LATENCY);
 
   // Record UMA statistics for the hardware configuration.
   RecordStats(output_params);
 
   Initialize();
 }
 
 AudioOutputResampler::~AudioOutputResampler() {
   DCHECK(callbacks_.empty());
 }
 
 void AudioOutputResampler::Initialize() {
   DCHECK(!streams_opened_);
   DCHECK(callbacks_.empty());
   dispatcher_ = new AudioOutputDispatcherImpl(
-      audio_manager_, output_params_, input_device_id_, close_delay_);
+      audio_manager_, output_params_, output_device_id_, input_device_id_,
+      close_delay_);
 }
 
 bool AudioOutputResampler::OpenStream() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   if (dispatcher_->OpenStream()) {
     // Only record the UMA statistic if we didn't fallback during construction
     // and only for the first stream we open.
     if (!streams_opened_ &&
         output_params_.format() == AudioParameters::AUDIO_PCM_LOW_LATENCY) {
@@ skipping 200 matching lines @@
   return frames > 0 ? 1 : 0;
 }
 
 void OnMoreDataConverter::OnError(AudioOutputStream* stream) {
   base::AutoLock auto_lock(source_lock_);
   if (source_callback_)
     source_callback_->OnError(stream);
 }
 
 }  // namespace media