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 111389)
+++ content/renderer/media/media_stream_dispatcher.cc	(working copy)
@@ -65,6 +65,40 @@
   label_stream_map_.erase(it);
 }
 
+void MediaStreamDispatcher::EnumerateVideoDevices(
+    int request_id,
+    MediaStreamDispatcherEventHandler* event_handler,
+    const std::string& security_origin) {
+  DVLOG(1) << "MediaStreamDispatcher::EnumerateVideoDevices("
+           << request_id << ")";
+
+  requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
+  Send(new MediaStreamHostMsg_EnumerateVideoDevices(routing_id(),
+                                                    next_ipc_id_++,
+                                                    security_origin));
+}
+
+void MediaStreamDispatcher::OpenVideoDevice(
+    int request_id,
+    MediaStreamDispatcherEventHandler* event_handler,
+    const std::string& device_id,
+    const std::string& security_origin) {
+  DVLOG(1) << "MediaStreamDispatcher::OpenVideoDevice(" << request_id << ")";
+
+  requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
+  Send(new MediaStreamHostMsg_OpenVideoDevice(routing_id(),
+                                              next_ipc_id_++,
+                                              device_id,
+                                              security_origin));
+}
+
+void MediaStreamDispatcher::CloseVideoDevice(const std::string& label) {
+  DVLOG(1) << "MediaStreamDispatcher::CloseVideoDevice"
+          << ", {label = " << label << "}";
+
+  StopStream(label);
+}
+
 bool MediaStreamDispatcher::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MediaStreamDispatcher, message)
@@ -76,6 +110,14 @@
                         OnVideoDeviceFailed)
     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_AudioDeviceFailed,
                         OnAudioDeviceFailed)
+    IPC_MESSAGE_HANDLER(MediaStreamMsg_VideoDevicesEnumerated,
+                        OnVideoDevicesEnumerated)
+    IPC_MESSAGE_HANDLER(MediaStreamMsg_VideoDevicesEnumerationFailed,
+                        OnVideoDevicesEnumerationFailed)
+    IPC_MESSAGE_HANDLER(MediaStreamMsg_VideoDeviceOpened,
+                        OnVideoDeviceOpened)
+    IPC_MESSAGE_HANDLER(MediaStreamMsg_VideoDeviceOpenFailed,
+                        OnVideoDeviceOpenFailed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ -148,6 +190,74 @@
   it->second.handler->OnAudioDeviceFailed(label, index);
 }
 
+void MediaStreamDispatcher::OnVideoDevicesEnumerated(
+    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->OnVideoDevicesEnumerated(request.request_id,
+                                                device_array);
+      DVLOG(1) << "MediaStreamDispatcher::OnVideoDevicesEnumerated("
+               << request.request_id << ")";
+      requests_.erase(it);
+      break;
+    }
+  }
+}
+
+void MediaStreamDispatcher::OnVideoDevicesEnumerationFailed(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::OnVideoDevicesEnumerationFailed("
+               << request.request_id << ")\n";
+      requests_.erase(it);
+      break;
+    }
+  }
+}
+
+void MediaStreamDispatcher::OnVideoDeviceOpened(
+    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->OnVideoDeviceOpened(request.request_id, label,
+                                           device_info);
+      DVLOG(1) << "MediaStreamDispatcher::OnVideoDeviceOpened("
+               << request.request_id << ", " << label << ")";
+      requests_.erase(it);
+      break;
+    }
+  }
+}
+
+void MediaStreamDispatcher::OnVideoDeviceOpenFailed(int request_id) {
+  for (RequestList::iterator it = requests_.begin();
+       it != requests_.end(); ++it) {
+    Request& request = *it;
+    if (request.ipc_request == request_id) {
+      request.handler->OnVideoDeviceOpenFailed(request.request_id);
+      DVLOG(1) << "MediaStreamDispatcher::OnVideoDeviceOpenFailed("
+               << 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);