test code for device enumeration from renderer process.

content/renderer/media/media_stream_impl.cc

 // 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.
 
 #include "content/renderer/media/media_stream_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 19 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaStreamRegistry.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 
 namespace {
 
 static const int kVideoCaptureWidth = 352;
 static const int kVideoCaptureHeight = 288;
 static const int kVideoCaptureFramePerSecond = 30;
 
+static const int kVideoCaptureWidthLarge = 640;
+static const int kVideoCaptureHeightLarge = 480;
+
 }  // namespace
 
 int MediaStreamImpl::next_request_id_ = 0;
 
 MediaStreamImpl::MediaStreamImpl(
     MediaStreamDispatcher* media_stream_dispatcher,
     content::P2PSocketDispatcher* p2p_socket_dispatcher,
     VideoCaptureImplManager* vc_manager,
     MediaStreamDependencyFactory* dependency_factory)
     : dependency_factory_(dependency_factory),
       media_stream_dispatcher_(media_stream_dispatcher),
       media_engine_(NULL),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       network_manager_(NULL),
       vc_manager_(vc_manager),
       peer_connection_handler_(NULL),
       message_loop_proxy_(base::MessageLoopProxy::current()),
       signaling_thread_(NULL),
       worker_thread_(NULL),
       chrome_worker_thread_("Chrome_libJingle_WorkerThread"),
+      desired_size_(0),
       vcm_created_(false) {
 }
 
 MediaStreamImpl::~MediaStreamImpl() {
   DCHECK(!peer_connection_handler_);
   if (dependency_factory_.get())
     dependency_factory_->DeletePeerConnectionFactory();
   if (network_manager_) {
     // The network manager needs to free its resources on the thread they were
     // created, which is the worked thread.
     if (chrome_worker_thread_.IsRunning()) {
       chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
           &MediaStreamImpl::DeleteIpcNetworkManager,
           base::Unretained(this)));
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
+void MediaStreamImpl::GetVideoDevice(int size) {
+  desired_size_ = size;
+  media_stream_dispatcher_->EnumerateDevices(next_request_id_++, this,
+                                             media_stream::kVideoCapture, "");
+}
+
 WebKit::WebPeerConnectionHandler* MediaStreamImpl::CreatePeerConnectionHandler(
     WebKit::WebPeerConnectionHandlerClient* client) {
   DCHECK(CalledOnValidThread());
   if (peer_connection_handler_) {
     DVLOG(1) << "A PeerConnection already exists";
     return NULL;
   }
 
   if (!media_engine_) {
     media_engine_ = dependency_factory_->CreateWebRtcMediaEngine();
@@ skipping 125 matching lines @@
 void MediaStreamImpl::cancelUserMediaRequest(
     const WebKit::WebUserMediaRequest& user_media_request) {
   // TODO(grunell): Implement.
   NOTIMPLEMENTED();
 }
 
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::GetVideoDecoder(
     const GURL& url,
     media::MessageLoopFactory* message_loop_factory) {
   DCHECK(CalledOnValidThread());
-  WebKit::WebMediaStreamDescriptor descriptor(
-      WebKit::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url));
-  if (descriptor.isNull())
-    return NULL;  // This is not a valid stream.
-  WebKit::WebVector<WebKit::WebMediaStreamSource> source_vector;
-  descriptor.sources(source_vector);
-  std::string label;
-  for (size_t i = 0; i < source_vector.size(); ++i) {
-    if (source_vector[i].type() == WebKit::WebMediaStreamSource::TypeVideo) {
-      label = UTF16ToUTF8(source_vector[i].id());
-      break;
-    }
-  }
+  std::string label = local_label_;
   if (label.empty())
     return NULL;
 
   scoped_refptr<media::VideoDecoder> decoder;
   if (media_stream_dispatcher_->IsStream(label)) {
     // It's a local stream.
     int video_session_id = media_stream_dispatcher_->video_session_id(label, 0);
+printf("MediaStreamImpl::GetVideoDecoder: use session_id = %d\n", video_session_id);  
+
     media::VideoCapture::VideoCaptureCapability capability;
-    capability.width = kVideoCaptureWidth;
-    capability.height = kVideoCaptureHeight;
+    if (desired_size_ == 0) {
+printf("MediaStreamImpl::GetVideoDecoder: use small size\n");  
+      capability.width = kVideoCaptureWidth;
+      capability.height = kVideoCaptureHeight;
+    } else {
+printf("MediaStreamImpl::GetVideoDecoder: use large size\n");  
+      capability.width = kVideoCaptureWidthLarge;
+      capability.height = kVideoCaptureHeightLarge;
+    }
     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("CaptureVideoDecoderThread"),
         video_session_id,
         vc_manager_.get(),
         capability);
   } else {
@@ skipping 86 matching lines @@
 
 void MediaStreamImpl::OnAudioDeviceFailed(const std::string& label,
                                           int index) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "MediaStreamImpl::OnAudioDeviceFailed("
            << label << ", " << index << ")";
   // TODO(grunell): Implement. Currently not supported in WebKit.
   NOTIMPLEMENTED();
 }
 
+void MediaStreamImpl::OnDevicesEnumerated(
+    int request_id,
+    const media_stream::StreamDeviceInfoArray& device_array) {
+  DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerated("
+           << request_id << ")";
+  media_stream::StreamDeviceInfoArray::const_iterator it;
+  for (it = device_array.begin(); it != device_array.end(); it++) {
+  }
+  if (!device_array.empty()) {
+    media_stream_dispatcher_->OpenDevice(
+        next_request_id_++, this,
+        device_array[0].device_id,
+        media_stream::kVideoCapture, "");
+  }
+}
+
+void MediaStreamImpl::OnDevicesEnumerationFailed(int request_id) {
+  DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerationFailed("
+           << request_id << ")";
+  NOTIMPLEMENTED();
+}
+
+void MediaStreamImpl::OnDeviceOpened(
+    int request_id,
+    const std::string& label,
+    const media_stream::StreamDeviceInfo& video_device) {
+  DVLOG(1) << "MediaStreamImpl::OnDeviceOpened("
+           << request_id << ", " << label << ")";
+  local_label_ = label;
+}
+
+void MediaStreamImpl::OnDeviceOpenFailed(int request_id) {
+  DVLOG(1) << "MediaStreamImpl::VideoDeviceOpenFailed("
+           << request_id << ")";
+  NOTIMPLEMENTED();
+}
+
 void MediaStreamImpl::InitializeWorkerThread(talk_base::Thread** thread,
                                              base::WaitableEvent* event) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentThread();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   *thread = jingle_glue::JingleThreadWrapper::current();
   event->Signal();
 }
 
 void MediaStreamImpl::DeleteIpcNetworkManager() {
   DCHECK_EQ(MessageLoop::current(), chrome_worker_thread_.message_loop());
   delete network_manager_;
   network_manager_ = NULL;
 }