support video device enumeration from renderer process.

content/renderer/media/media_stream_impl.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_impl.h"
 
 #include "base/string_util.h"
 #include "content/renderer/media/capture_video_decoder.h"
+#include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "googleurl/src/gurl.h"
 #include "media/base/message_loop_factory.h"
 #include "media/base/pipeline.h"
 
 namespace {
 
 static const int kVideoCaptureWidth = 352;
 static const int kVideoCaptureHeight = 288;
 static const int kVideoCaptureFramePerSecond = 30;
 
 static const int kStartOpenSessionId = 1;
 
 // TODO(wjia): remove this string when full media stream code is checked in.
 static const char kRawMediaScheme[] = "mediastream";
 
 }  // namespace
 
-MediaStreamImpl::MediaStreamImpl(VideoCaptureImplManager* vc_manager)
-    : vc_manager_(vc_manager) {
+MediaStreamImpl::MediaStreamImpl(
+    MediaStreamDispatcher* media_stream_dispatcher,
+    VideoCaptureImplManager* vc_manager)
+    : media_stream_dispatcher_(media_stream_dispatcher),
+      vc_manager_(vc_manager) {
+  DCHECK(media_stream_dispatcher);
 }
 
 MediaStreamImpl::~MediaStreamImpl() {}
 
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::GetVideoDecoder(
     const GURL& url, media::MessageLoopFactory* message_loop_factory) {
   bool raw_media = (url.spec().find(kRawMediaScheme) == 0);
   media::VideoDecoder* decoder = NULL;
+  int session_id = media_stream_dispatcher_->video_session_id(local_label_, 0);
+  if (session_id == media_stream::StreamDeviceInfo::kNoId)
+    session_id = kStartOpenSessionId;
   if (raw_media) {
     media::VideoCapture::VideoCaptureCapability capability;
     capability.width = kVideoCaptureWidth;
     capability.height = kVideoCaptureHeight;
     capability.max_fps = kVideoCaptureFramePerSecond;
     capability.expected_capture_delay = 0;
     capability.raw_type = media::VideoFrame::I420;
     capability.interlaced = false;
 
     decoder = new CaptureVideoDecoder(
         message_loop_factory->GetMessageLoopProxy("CaptureVideoDecoder").get(),
-        kStartOpenSessionId, vc_manager_.get(), capability);
+        session_id, vc_manager_.get(), capability);
   }
   return decoder;
 }
+
+void MediaStreamImpl::OnStreamGenerated(
+    int request_id,
+    const std::string& label,
+    const media_stream::StreamDeviceInfoArray& audio_array,
+    const media_stream::StreamDeviceInfoArray& video_array) {
+  DVLOG(1) << "MediaStreamImpl::OnStreamGenerated("
+           << request_id << ", " << label << ")";
+  NOTIMPLEMENTED();
+}
+
+void MediaStreamImpl::OnStreamGenerationFailed(int request_id) {
+  DVLOG(1) << "MediaStreamImpl::OnStreamGenerationFailed("
+           << request_id << ")";
+  NOTIMPLEMENTED();
+}
+
+void MediaStreamImpl::OnVideoDeviceFailed(const std::string& label,
+                                          int index) {
+  DVLOG(1) << "MediaStreamImpl::OnVideoDeviceFailed("
+           << label << ", " << index << ")";
+  NOTIMPLEMENTED();
+}
+
+void MediaStreamImpl::OnAudioDeviceFailed(const std::string& label,
+                                          int index) {
+  DVLOG(1) << "MediaStreamImpl::OnAudioDeviceFailed("
+           << label << ", " << index << ")";
+  NOTIMPLEMENTED();
+}
+
+void MediaStreamImpl::OnVideoDevicesEnumerated(
+    int request_id,
+    const media_stream::StreamDeviceInfoArray& device_array) {
+  DVLOG(1) << "MediaStreamImpl::OnVideoDevicesEnumerated("
+           << request_id << ")";
+  NOTIMPLEMENTED();
+}
+
+void MediaStreamImpl::OnVideoDevicesEnumerationFailed(int request_id) {
+  DVLOG(1) << "MediaStreamImpl::OnVideoDevicesEnumerationFailed("
+           << request_id << ")";
+  NOTIMPLEMENTED();
+}
+
+void MediaStreamImpl::OnVideoDeviceOpened(
+    int request_id,
+    const std::string& label,
+    const media_stream::StreamDeviceInfo& video_device) {
+  DVLOG(1) << "MediaStreamImpl::OnVideoDeviceOpened("
+           << request_id << ", " << label << ")";
+  NOTIMPLEMENTED();
+}
+
+void MediaStreamImpl::OnVideoDeviceOpenFailed(int request_id) {
+  DVLOG(1) << "MediaStreamImpl::VideoDeviceOpenFailed("
+           << request_id << ")";
+  NOTIMPLEMENTED();
+}