Adds COM init to AudioManager thread for Windows

media/audio/audio_manager_base.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_manager_base.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/thread.h"
+#include "base/win/scoped_com_initializer.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_output_resampler.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "media/base/media_switches.h"
 
 // TODO(dalecurtis): Temporarily disabled while switching pipeline to use float,
 // http://crbug.com/114700
 #if defined(ENABLE_AUDIO_MIXER)
 #include "media/audio/audio_output_mixer.h"
 #endif
 
+using base::win::ScopedCOMInitializer;
+
 namespace media {
 
 static const int kStreamCloseDelaySeconds = 5;
 
 // Default maximum number of output streams that can be open simultaneously
 // for all platforms.
 static const int kDefaultMaxOutputStreams = 16;
 
 // Default maximum number of input streams that can be open simultaneously
 // for all platforms.
 static const int kDefaultMaxInputStreams = 16;
 
 static const int kMaxInputChannels = 2;
 
 const char AudioManagerBase::kDefaultDeviceName[] = "Default";
 const char AudioManagerBase::kDefaultDeviceId[] = "default";
 
+// Initializes the COM library for use by this thread and sets the thread's
+// COM threading model on Windows to MTA.
+class AudioThread : public base::Thread {
+ public:
+  AudioThread();
+  virtual ~AudioThread();
+
+ protected:
+  virtual void Init() OVERRIDE;
+  virtual void CleanUp() OVERRIDE;
+
+ private:
+  scoped_ptr<ScopedCOMInitializer> com_initializer_;
+  DISALLOW_COPY_AND_ASSIGN(AudioThread);
+};
+
+AudioThread::AudioThread() : base::Thread("AudioThread") {
+}
+
+AudioThread::~AudioThread() {}
+
+void AudioThread::Init() {
+  com_initializer_.reset(new ScopedCOMInitializer(ScopedCOMInitializer::kMTA));
+  CHECK(com_initializer_->succeeded());
+}
+
+void AudioThread::CleanUp() {
+  com_initializer_.reset();
+}
+
 AudioManagerBase::AudioManagerBase()
     : num_active_input_streams_(0),
       max_num_output_streams_(kDefaultMaxOutputStreams),
       max_num_input_streams_(kDefaultMaxInputStreams),
       num_output_streams_(0),
       num_input_streams_(0) {
 }
 
 AudioManagerBase::~AudioManagerBase() {
   // The platform specific AudioManager implementation must have already
   // stopped the audio thread. Otherwise, we may destroy audio streams before
   // stopping the thread, resulting an unexpected behavior.
   // This way we make sure activities of the audio streams are all stopped
   // before we destroy them.
   CHECK(!audio_thread_.get());
   // All the output streams should have been deleted.
   DCHECK_EQ(0, num_output_streams_);
   // All the input streams should have been deleted.
   DCHECK_EQ(0, num_input_streams_);
 }
 
 void AudioManagerBase::Init() {
   base::AutoLock lock(audio_thread_lock_);
   DCHECK(!audio_thread_.get());
-  audio_thread_.reset(new base::Thread("AudioThread"));
+  audio_thread_.reset(new media::AudioThread());
   CHECK(audio_thread_->Start());
 }
 
 string16 AudioManagerBase::GetAudioInputDeviceModel() {
   return string16();
 }
 
 scoped_refptr<base::MessageLoopProxy> AudioManagerBase::GetMessageLoop() {
   base::AutoLock lock(audio_thread_lock_);
   return audio_thread_.get() ? audio_thread_->message_loop_proxy() : NULL;
@@ skipping 144 matching lines @@
   base::AtomicRefCountDec(&num_active_input_streams_);
 }
 
 bool AudioManagerBase::IsRecordingInProcess() {
   return !base::AtomicRefCountIsZero(&num_active_input_streams_);
 }
 
 void AudioManagerBase::Shutdown() {
   // To avoid running into deadlocks while we stop the thread, shut it down
   // via a local variable while not holding the audio thread lock.
-  scoped_ptr<base::Thread> audio_thread;
+  scoped_ptr<media::AudioThread> audio_thread;
   {
     base::AutoLock lock(audio_thread_lock_);
     audio_thread_.swap(audio_thread);
   }
 
   if (!audio_thread.get())
     return;
 
   CHECK_NE(MessageLoop::current(), audio_thread->message_loop());
 
@@ skipping 44 matching lines @@
 #else
   // TODO(dalecurtis): This should include bits per channel and channel layout
   // eventually.
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, input_params.channel_layout(),
       GetAudioHardwareSampleRate(), 16, GetAudioHardwareBufferSize());
 #endif  // defined(OS_IOS)
 }
 
 }  // namespace media