Move the device enumerate/open/close work to device thread from IO thread

content/browser/renderer_host/media/audio_input_device_manager.cc

Index: content/browser/renderer_host/media/audio_input_device_manager.cc
diff --git a/content/browser/renderer_host/media/audio_input_device_manager.cc b/content/browser/renderer_host/media/audio_input_device_manager.cc
index 00e37f9a5c5f8cec6f6950a7ff1cb1add97d0a5b..f4c2adcf70c1ffd8709b1f89b8dd42ab7e5416e4 100644
--- a/content/browser/renderer_host/media/audio_input_device_manager.cc
+++ b/content/browser/renderer_host/media/audio_input_device_manager.cc
@@ -6,10 +6,12 @@
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
+#include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager_event_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/audio/audio_manager_base.h"
 
+using content::BrowserMainLoop;
 using content::BrowserThread;
 
 namespace media_stream {
@@ -22,10 +24,10 @@ const char AudioInputDeviceManager::kInvalidDeviceId[] = "";
 const int kFirstSessionId = AudioInputDeviceManager::kFakeOpenSessionId + 1;
 
 AudioInputDeviceManager::AudioInputDeviceManager(
-    media::AudioManager* audio_manager)
+    scoped_refptr<base::MessageLoopProxy> message_loop)
     : listener_(NULL),
       next_capture_session_id_(kFirstSessionId),
-      audio_manager_(audio_manager) {
+      message_loop_(message_loop) {
 }
 
 AudioInputDeviceManager::~AudioInputDeviceManager() {
@@ -47,8 +49,37 @@ void AudioInputDeviceManager::EnumerateDevices() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(listener_);
 
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioInputDeviceManager::EnumerateOnDeviceThread, this));
+}
+
+int AudioInputDeviceManager::Open(const StreamDeviceInfo& device) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  // Generates a new id for this device.
+  int session_id = next_capture_session_id_++;
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioInputDeviceManager::OpenOnDeviceThread,
+                 this, session_id, device));
+
+  return session_id;
+}
+
+void AudioInputDeviceManager::Close(int session_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(listener_);
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioInputDeviceManager::CloseOnDeviceThread,
+                 this, session_id));
+}
+
+void AudioInputDeviceManager::EnumerateOnDeviceThread() {
+  DCHECK(IsOnDeviceThread());
+  // TODO(xians): Ensure AudioManager outlives MediaStreamManager.

[tommi (sloooow) - chröme, 2012/07/02 13:36:36]

Is the device thread guaranteed to have terminated before any of the "known"
Chrome thread such as the IO thread or the main browser loop?

If so, then you can safely call GetAudioManager() here without worrying if it's
valid or not since if the device thread is running, you're guaranteed that
BrowserLoop is valid.

If not, then I think we should fix that and here is not where we need to fix it.
 It should be a property of the device thread itself that it does never outlive
the browser loop and/or IO thread.

[no longer working on chromium, 2012/07/04 12:35:25]

Done.

   media::AudioDeviceNames device_names;
-  audio_manager_->GetAudioInputDeviceNames(&device_names);
+  BrowserMainLoop::GetAudioManager()->GetAudioInputDeviceNames(&device_names);
 
   StreamDeviceInfoArray* devices = new StreamDeviceInfoArray;
   for (media::AudioDeviceNames::iterator it = device_names.begin();
@@ -69,19 +100,14 @@ void AudioInputDeviceManager::EnumerateDevices() {
                  devices));
 }
 
-int AudioInputDeviceManager::Open(const StreamDeviceInfo& device) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  // Generates a new id for this device.
-  int session_id = next_capture_session_id_++;
+void AudioInputDeviceManager::OpenOnDeviceThread(
+    int session_id, const StreamDeviceInfo& device) {
+  DCHECK(IsOnDeviceThread());
   DCHECK(devices_.find(session_id) == devices_.end());
 
-  media::AudioDeviceName audio_input_device_name;
-  audio_input_device_name.device_name = device.name;
-  audio_input_device_name.unique_id = device.device_id;
-
   // Adds the session_id and device to the list.
-  devices_[session_id] = audio_input_device_name;
+  media::AudioDeviceName target_device(device.name, device.device_id);
+  devices_[session_id] = target_device;
 
   // Returns the |session_id| through the listener by posting a task on
   // IO thread since MediaStreamManager handles the callback asynchronously.
@@ -90,13 +116,10 @@ int AudioInputDeviceManager::Open(const StreamDeviceInfo& device) {
                           base::Bind(&AudioInputDeviceManager::OpenedOnIOThread,
                                      this,
                                      session_id));
-
-  return session_id;
 }
 
-void AudioInputDeviceManager::Close(int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(listener_);
+void AudioInputDeviceManager::CloseOnDeviceThread(int session_id) {
+  DCHECK(IsOnDeviceThread());
 
   if (devices_.find(session_id) != devices_.end())
     devices_.erase(session_id);
@@ -181,4 +204,8 @@ void AudioInputDeviceManager::ClosedOnIOThread(int session_id) {
                       session_id);
 }
 
+bool AudioInputDeviceManager::IsOnDeviceThread() const {
+  return message_loop_->BelongsToCurrentThread();
+}
+
 }  // namespace media_stream