Begin adding support for tab mirroring via the MediaStream audio/video capturing

content/browser/renderer_host/media/audio_input_device_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/audio_input_device_manager.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager_event_handler.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/common/media_stream_request.h"
+#include "media/audio/audio_device_name.h"
 #include "media/audio/audio_input_ipc.h"
 #include "media/audio/audio_manager_base.h"
 
 using content::BrowserThread;
 
 namespace media_stream {
 
 const int AudioInputDeviceManager::kFakeOpenSessionId = 1;
 
 // Starting id for the first capture session.
@@ skipping 65 matching lines @@
   DCHECK(IsOnDeviceThread());
   // AudioManager is guaranteed to outlive MediaStreamManager in
   // BrowserMainloop.
   media::AudioDeviceNames device_names;
   audio_manager_->GetAudioInputDeviceNames(&device_names);
 
   StreamDeviceInfoArray* devices = new StreamDeviceInfoArray;
   for (media::AudioDeviceNames::iterator it = device_names.begin();
        it != device_names.end();
        ++it) {
-         devices->push_back(StreamDeviceInfo(
-            content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE, it->device_name,
-            it->unique_id, false));
+    // NOTE: Only support enumeration of the MEDIA_DEVICE_AUDIO_CAPTURE type.
+    devices->push_back(StreamDeviceInfo(
+        content::MEDIA_DEVICE_AUDIO_CAPTURE, it->device_name,
+        it->unique_id, false));
   }
 
   // Returns the device list through the listener by posting a task on
   // IO thread since MediaStreamManager handles the callback asynchronously.
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&AudioInputDeviceManager::DevicesEnumeratedOnIOThread,
                  this,
                  devices));
 }
 
 void AudioInputDeviceManager::OpenOnDeviceThread(
     int session_id, const StreamDeviceInfo& device) {
   DCHECK(IsOnDeviceThread());
   DCHECK(devices_.find(session_id) == devices_.end());
 
-  // Adds the session_id and device to the list.
-  media::AudioDeviceName target_device(device.name, device.device_id);
-  devices_[session_id] = target_device;
+  // Adds the session_id and device to the map.
+  devices_[session_id] = device;
 
   // Returns the |session_id| through the listener by posting a task on
   // IO thread since MediaStreamManager handles the callback asynchronously.
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&AudioInputDeviceManager::OpenedOnIOThread,
                                      this,
-                                     session_id));
+                                     device.stream_type, session_id));
 }
 
 void AudioInputDeviceManager::CloseOnDeviceThread(int session_id) {
   DCHECK(IsOnDeviceThread());
 
-  if (devices_.find(session_id) != devices_.end())
-    devices_.erase(session_id);
+  StreamDeviceMap::iterator it = devices_.find(session_id);
+  if (it == devices_.end()) {

[tommi (sloooow) - chröme, 2012/09/10 09:17:25]

no {} for cases like this.  See how this is done elsewhere in this file.

[miu, 2012/09/10 21:24:38]

Done.

+    return;
+  }
+  const content::MediaStreamDeviceType stream_type = it->second.stream_type;
+  devices_.erase(it);
 
   // Posts a callback through the listener on IO thread since
   // MediaStreamManager handles the callback asynchronously.
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&AudioInputDeviceManager::ClosedOnIOThread,
                                      this,
-                                     session_id));
+                                     stream_type, session_id));
 }
 
 void AudioInputDeviceManager::Start(
     int session_id, AudioInputDeviceManagerEventHandler* event_handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(event_handler);
 
   // Solution for not using MediaStreamManager. This is needed when Start() is
   // called without using Open(), we post default device for test purpose.
   // And we do not store the info for the kFakeOpenSessionId but return
   // the callback immediately.
   if (session_id == kFakeOpenSessionId) {
     event_handler->OnDeviceStarted(session_id,
                                    media::AudioManagerBase::kDefaultDeviceId);
     return;
   }
 
   // Checks if the device has been opened or not.
   std::string device_id;
 
   // Adds the event handler to the session if the session has not been started,
   // otherwise post an empty |device_id| to indicate that Start() fails.
   if (event_handlers_.find(session_id) == event_handlers_.end()) {
     event_handlers_.insert(std::make_pair(session_id, event_handler));
     if (devices_.find(session_id) != devices_.end())
-      device_id = devices_[session_id].unique_id;
+      device_id = devices_[session_id].device_id;
   }
 
   // Posts a callback through the AudioInputRendererHost to notify the renderer
   // that the device has started.
   event_handler->OnDeviceStarted(session_id, device_id);
 }
 
 void AudioInputDeviceManager::Stop(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Erases the event handler referenced by the session_id.
   event_handlers_.erase(session_id);
 }
 
 void AudioInputDeviceManager::DevicesEnumeratedOnIOThread(
     StreamDeviceInfoArray* devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Ensures that |devices| gets deleted on exit.
   scoped_ptr<StreamDeviceInfoArray> devices_array(devices);
   if (listener_) {
-    listener_->DevicesEnumerated(
-        content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
-        *devices_array);
+    // NOTE: Only support enumeration of the MEDIA_DEVICE_AUDIO_CAPTURE type.
+    listener_->DevicesEnumerated(content::MEDIA_DEVICE_AUDIO_CAPTURE,
+                                 *devices_array);
   }
 }
 
-void AudioInputDeviceManager::OpenedOnIOThread(int session_id) {
+void AudioInputDeviceManager::OpenedOnIOThread(
+    content::MediaStreamDeviceType stream_type, int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (listener_)
-    listener_->Opened(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
-                      session_id);
+    listener_->Opened(stream_type, session_id);
 }
 
-void AudioInputDeviceManager::ClosedOnIOThread(int session_id) {
+void AudioInputDeviceManager::ClosedOnIOThread(
+    content::MediaStreamDeviceType stream_type, int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (listener_)
-    listener_->Closed(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
-                      session_id);
+    listener_->Closed(stream_type, session_id);
 }
 
 bool AudioInputDeviceManager::IsOnDeviceThread() const {
   return device_loop_->BelongsToCurrentThread();
 }
 
 }  // namespace media_stream