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_input_ipc.h"
 #include "media/audio/audio_manager_base.h"
 
 using content::BrowserThread;
 
 namespace media_stream {
 
+namespace {
+const char kStubTabAudioDeviceId[] = "<<tab audio id here>>";
+}
+
 const int AudioInputDeviceManager::kFakeOpenSessionId = 1;
 
 // Starting id for the first capture session.
 const int kFirstSessionId = AudioInputDeviceManager::kFakeOpenSessionId + 1;
 
 AudioInputDeviceManager::AudioInputDeviceManager(
-    media::AudioManager* audio_manager)
-    : listener_(NULL),
+    media::AudioManager* audio_manager,
+    media_stream::MediaStreamType device_type)
+    : device_type_(device_type),
+      listener_(NULL),
       next_capture_session_id_(kFirstSessionId),
       audio_manager_(audio_manager) {
+  DCHECK(content::IsAudioMediaStreamDeviceType(device_type_));
 }
 
 AudioInputDeviceManager::~AudioInputDeviceManager() {
 }
 
 void AudioInputDeviceManager::Register(
     MediaStreamProviderListener* listener,
     base::MessageLoopProxy* device_thread_loop) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!listener_);
@@ skipping 39 matching lines @@
   }
 
   device_loop_->PostTask(
       FROM_HERE,
       base::Bind(&AudioInputDeviceManager::CloseOnDeviceThread,
                  this, session_id));
 }
 
 void AudioInputDeviceManager::EnumerateOnDeviceThread() {
   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));
+  switch (device_type_) {
+    case content::MEDIA_STREAM_DEVICE_TYPE_USER_AUDIO_CAPTURE: {
+      // AudioManager is guaranteed to outlive MediaStreamManager in
+      // BrowserMainloop.
+      media::AudioDeviceNames device_names;
+      audio_manager_->GetAudioInputDeviceNames(&device_names);
+      for (media::AudioDeviceNames::iterator it = device_names.begin();
+           it != device_names.end(); ++it) {
+        devices->push_back(StreamDeviceInfo(
+            device_type_, it->device_name, it->unique_id, false));
+      }
+      break;
+    }
+    case content::MEDIA_STREAM_DEVICE_TYPE_TAB_AUDIO_CAPTURE:
+      // TODO(miu): Replace this stub with the actual implementation.
+      devices->push_back(StreamDeviceInfo(
+          device_type_, "Stub Tab Audio Capture", kStubTabAudioDeviceId,
+          false));
+      break;
+    default:
+      NOTIMPLEMENTED();
+      break;
   }
 
   // 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;
+  // TODO(miu): Complete the implementation (i.e., actually open a device).

[no longer working on chromium, 2012/08/31 13:38:23]

I am not sure if we should actually open a device here.

the audio path in chrome currently has only two APIs for its clients,
start()/stop(), please check the AudioOutputDevice or AudioInputDevice. Where
start() will create/start an audio stream, and stop() will close/delete the
stream.

If I don't remember wrong, users can open multiple devices but only start one of
them. Since open/start an audio device are usually quick, so we open the device
when we are really using it. (in start())

[miu, 2012/09/01 01:32:00]

Thanks for the explanation.  I've removed this TODO comment.

 
   // 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));
 }
 
 void AudioInputDeviceManager::CloseOnDeviceThread(int session_id) {
   DCHECK(IsOnDeviceThread());
 
   if (devices_.find(session_id) != devices_.end())
     devices_.erase(session_id);
+  // TODO(miu): Complete the implementation (i.e., actually close a device).

[no longer working on chromium, 2012/08/31 13:38:23]

Stop() has already close the device, not sure if we should break it into two.

[miu, 2012/09/01 01:32:00]

Removed this comment too.

 
   // 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));
 }
 
@@ skipping 34 matching lines @@
   // 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);
+    listener_->DevicesEnumerated(device_type_, *devices_array);
   }
 }
 
 void AudioInputDeviceManager::OpenedOnIOThread(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (listener_)
-    listener_->Opened(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
-                      session_id);
+    listener_->Opened(device_type_, session_id);
 }
 
 void AudioInputDeviceManager::ClosedOnIOThread(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (listener_)
-    listener_->Closed(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
-                      session_id);
+    listener_->Closed(device_type_, session_id);
 }
 
 bool AudioInputDeviceManager::IsOnDeviceThread() const {
   return device_loop_->BelongsToCurrentThread();
 }
 
 }  // namespace media_stream