support video device enumeration from renderer process.

1. renderer process sends EnumerateDevices message to browser process, and expect DevicesEnumerated or DeivcesEnumerationFailed message.
2. renderer process sends OpenDevice message to browser process, and expect DeviceOpened or DeviceOpenFailed message.
3. after renderer process gets DeviceOpened message, it can use |label| to get the session_id which is the identifier to Start/Stop video capture.
4. renderer process re-uses StopGeneratedStream for CloseOpenedDevice.
5. simplify interface between MediaStreamManager and MediaStreamDeviceSettings by removing GetDevices function call.

The test example code is at http://codereview.chromium.org/8511074/

BUG=41777
TEST=trybots
Review URL: https://chromiumcodereview.appspot.com/8480028

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@119139 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 114 insertions, 1 deletions

diff --git a/content/renderer/media/media_stream_dispatcher.cc b/content/renderer/media/media_stream_dispatcher.cc
index 12263f5..6bf81d8 100644
--- a/content/renderer/media/media_stream_dispatcher.cc
+++ b/content/renderer/media/media_stream_dispatcher.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -65,6 +65,44 @@ void MediaStreamDispatcher::StopStream(const std::string& label) {
   label_stream_map_.erase(it);
 }
 
+void MediaStreamDispatcher::EnumerateDevices(
+    int request_id,
+    MediaStreamDispatcherEventHandler* event_handler,
+    media_stream::MediaStreamType type,
+    const std::string& security_origin) {
+  DVLOG(1) << "MediaStreamDispatcher::EnumerateDevices("
+           << request_id << ")";
+
+  requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
+  Send(new MediaStreamHostMsg_EnumerateDevices(routing_id(),
+                                               next_ipc_id_++,
+                                               type,
+                                               security_origin));
+}
+
+void MediaStreamDispatcher::OpenDevice(
+    int request_id,
+    MediaStreamDispatcherEventHandler* event_handler,
+    const std::string& device_id,
+    media_stream::MediaStreamType type,
+    const std::string& security_origin) {
+  DVLOG(1) << "MediaStreamDispatcher::OpenDevice(" << request_id << ")";
+
+  requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
+  Send(new MediaStreamHostMsg_OpenDevice(routing_id(),
+                                         next_ipc_id_++,
+                                         device_id,
+                                         type,
+                                         security_origin));
+}
+
+void MediaStreamDispatcher::CloseDevice(const std::string& label) {
+  DVLOG(1) << "MediaStreamDispatcher::CloseDevice"
+           << ", {label = " << label << "}";
+
+  StopStream(label);
+}
+
 bool MediaStreamDispatcher::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MediaStreamDispatcher, message)
@@ -76,6 +114,14 @@ bool MediaStreamDispatcher::OnMessageReceived(const IPC::Message& message) {
                         OnVideoDeviceFailed)
     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_AudioDeviceFailed,
                         OnAudioDeviceFailed)
+    IPC_MESSAGE_HANDLER(MediaStreamMsg_DevicesEnumerated,
+                        OnDevicesEnumerated)
+    IPC_MESSAGE_HANDLER(MediaStreamMsg_DevicesEnumerationFailed,
+                        OnDevicesEnumerationFailed)
+    IPC_MESSAGE_HANDLER(MediaStreamMsg_DeviceOpened,
+                        OnDeviceOpened)
+    IPC_MESSAGE_HANDLER(MediaStreamMsg_DeviceOpenFailed,
+                        OnDeviceOpenFailed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ -148,6 +194,73 @@ void MediaStreamDispatcher::OnAudioDeviceFailed(const std::string& label,
   it->second.handler->OnAudioDeviceFailed(label, index);
 }
 
+void MediaStreamDispatcher::OnDevicesEnumerated(
+    int request_id,
+    const media_stream::StreamDeviceInfoArray& device_array) {
+
+  for (RequestList::iterator it = requests_.begin();
+       it != requests_.end(); ++it) {
+    Request& request = *it;
+    if (request.ipc_request == request_id) {
+      request.handler->OnDevicesEnumerated(request.request_id, device_array);
+      DVLOG(1) << "MediaStreamDispatcher::OnDevicesEnumerated("
+               << request.request_id << ")";
+      requests_.erase(it);
+      break;
+    }
+  }
+}
+
+void MediaStreamDispatcher::OnDevicesEnumerationFailed(int request_id) {
+  for (RequestList::iterator it = requests_.begin();
+       it != requests_.end(); ++it) {
+    Request& request = *it;
+    if (request.ipc_request == request_id) {
+      request.handler->OnStreamGenerationFailed(request.request_id);
+      DVLOG(1) << "MediaStreamDispatcher::OnDevicesEnumerationFailed("
+               << request.request_id << ")\n";
+      requests_.erase(it);
+      break;
+    }
+  }
+}
+
+void MediaStreamDispatcher::OnDeviceOpened(
+    int request_id,
+    const std::string& label,
+    const media_stream::StreamDeviceInfo& device_info) {
+  for (RequestList::iterator it = requests_.begin();
+       it != requests_.end(); ++it) {
+    Request& request = *it;
+    if (request.ipc_request == request_id) {
+      Stream new_stream;
+      new_stream.handler = request.handler;
+      new_stream.video_array.push_back(device_info);
+      label_stream_map_[label] = new_stream;
+      request.handler->OnDeviceOpened(request.request_id, label,
+                                      device_info);
+      DVLOG(1) << "MediaStreamDispatcher::OnDeviceOpened("
+               << request.request_id << ", " << label << ")";
+      requests_.erase(it);
+      break;
+    }
+  }
+}
+
+void MediaStreamDispatcher::OnDeviceOpenFailed(int request_id) {
+  for (RequestList::iterator it = requests_.begin();
+       it != requests_.end(); ++it) {
+    Request& request = *it;
+    if (request.ipc_request == request_id) {
+      request.handler->OnDeviceOpenFailed(request.request_id);
+      DVLOG(1) << "MediaStreamDispatcher::OnDeviceOpenFailed("
+               << request.request_id << ")\n";
+      requests_.erase(it);
+      break;
+    }
+  }
+}
+
 int MediaStreamDispatcher::audio_session_id(const std::string& label,
                                             int index) {
   LabelStreamMap::iterator it = label_stream_map_.find(label);