support video device enumeration from renderer process.

content/renderer/media/media_stream_dispatcher.cc

Index: content/renderer/media/media_stream_dispatcher.cc
===================================================================
--- content/renderer/media/media_stream_dispatcher.cc	(revision 118766)
+++ content/renderer/media/media_stream_dispatcher.cc	(working copy)
@@ -65,6 +65,44 @@
   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 @@
                         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 @@
   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);