support video device enumeration from renderer process.

content/renderer/media/media_stream_dispatcher.cc

 // Copyright (c) 2011 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/renderer/media/media_stream_dispatcher.h"
 
 #include "base/logging.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
 #include "content/renderer/render_view_impl.h"
@@ skipping 47 matching lines @@
            << ", {label = " << label << "}";
 
   LabelStreamMap::iterator it = label_stream_map_.find(label);
   if (it == label_stream_map_.end())
     return;
 
   Send(new MediaStreamHostMsg_StopGeneratedStream(routing_id(), label));
   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)
     IPC_MESSAGE_HANDLER(MediaStreamMsg_StreamGenerated,
                         OnStreamGenerated)
     IPC_MESSAGE_HANDLER(MediaStreamMsg_StreamGenerationFailed,
                         OnStreamGenerationFailed)
     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_VideoDeviceFailed,
                         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;
 }
 
 void MediaStreamDispatcher::OnStreamGenerated(
     int request_id,
     const std::string& label,
     const media_stream::StreamDeviceInfoArray& audio_array,
     const media_stream::StreamDeviceInfoArray& video_array) {
@@ skipping 52 matching lines @@
     return;
 
   // index is the index in the audio_array that has failed.
   DCHECK_GT(it->second.audio_array.size(), static_cast<size_t>(index));
   media_stream::StreamDeviceInfoArray::iterator device_it =
       it->second.audio_array.begin();
   it->second.audio_array.erase(device_it + index);
   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);
   if (it == label_stream_map_.end())
     return media_stream::StreamDeviceInfo::kNoId;
 
   DCHECK_GT(it->second.audio_array.size(), static_cast<size_t>(index));
   return it->second.audio_array[index].session_id;
 }
 
 bool MediaStreamDispatcher::IsStream(const std::string& label) {
   return label_stream_map_.find(label) != label_stream_map_.end();
 }
 
 int MediaStreamDispatcher::video_session_id(const std::string& label,
                                             int index) {
   LabelStreamMap::iterator it = label_stream_map_.find(label);
   if (it == label_stream_map_.end())
     return media_stream::StreamDeviceInfo::kNoId;
 
   DCHECK_GT(it->second.video_array.size(), static_cast<size_t>(index));
   return it->second.video_array[index].session_id;
 }