Allow Thread to initialize COM for Windows consumers who need it

content/browser/renderer_host/media/media_stream_manager.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 "content/browser/renderer_host/media/media_stream_manager.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
+#include "base/threading/thread.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/media_stream_requester.h"
 #include "content/browser/renderer_host/media/media_stream_ui_controller.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/media_observer.h"
 #include "content/public/browser/media_request_state.h"
 #include "content/public/common/media_stream_request.h"
@@ skipping 31 matching lines @@
   return label;
 }
 
 // Helper to verify if a media stream type is part of options or not.
 static bool Requested(const StreamOptions& options,
                       MediaStreamType stream_type) {
   return (options.audio_type == stream_type ||
           options.video_type == stream_type);
 }
 
-#if defined(OS_WIN)
-DeviceThread::DeviceThread(const char* name) : base::Thread(name) {
-}
-
-DeviceThread::~DeviceThread() {
-  Stop();
-}
-
-void DeviceThread::Init() {
-  com_initializer_.reset(new base::win::ScopedCOMInitializer(
-      base::win::ScopedCOMInitializer::kMTA));
-}
-
-void DeviceThread::CleanUp() {
-  com_initializer_.reset();
-}
-#endif
-
 // TODO(xians): Merge DeviceRequest with MediaStreamRequest.
 class MediaStreamManager::DeviceRequest {
  public:
   enum RequestType {
     DEVICE_ACCESS = 0,
     GENERATE_STREAM,
     ENUMERATE_DEVICES,
     OPEN_DEVICE
   };
 
@@ skipping 489 matching lines @@
                                 request.render_view_id,
                                 request.options,
                                 request.security_origin);
 }
 
 void MediaStreamManager::EnsureDeviceManagersStarted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (device_thread_.get())
     return;
 
-  device_thread_.reset(new DeviceThread("MediaStreamDeviceThread"));
+  device_thread_.reset(new base::Thread("MediaStreamDeviceThread"));
+#if defined(OS_WIN)
+  device_thread_->init_com_with_mta(true);
+#endif
   CHECK(device_thread_->Start());
 
   audio_input_device_manager_ =
       new media_stream::AudioInputDeviceManager(audio_manager_);
   audio_input_device_manager_->Register(this,
                                         device_thread_->message_loop_proxy());
 
   video_capture_manager_ = new media_stream::VideoCaptureManager();
   video_capture_manager_->Register(this,
                                    device_thread_->message_loop_proxy());
@@ skipping 454 matching lines @@
        it != requests_.end(); ++it) {
     if (it->second.type == DeviceRequest::ENUMERATE_DEVICES &&
         Requested(it->second.options, stream_type)) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace media_stream