Hook up EncodedVideoSource on the browser side

content/browser/renderer_host/media/video_capture_manager.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/browser/renderer_host/media/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 97 matching lines @@
     media::VideoCaptureDevice::EventHandler* video_capture_receiver) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   device_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::OnStart, this, capture_params,
                  video_capture_receiver));
 }
 
 void VideoCaptureManager::Stop(
     const media::VideoCaptureSessionId& capture_session_id,
-    base::Closure stopped_cb) {
+    const base::Closure& stopped_cb) {
   DVLOG(1) << "VideoCaptureManager::Stop, id " << capture_session_id;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   device_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::OnStop, this, capture_session_id,
                  stopped_cb));
 }
 
+void VideoCaptureManager::TryConfigureEncodedBitstream(
+    const media::VideoCaptureSessionId& session_id,
+    const media::RuntimeVideoEncodingParameters& params) {
+  device_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &VideoCaptureManager::OnTryConfigureEncodedBitstream,
+          this,
+          session_id,
+          params));
+}
+
 void VideoCaptureManager::UseFakeDevice() {
   use_fake_device_ = true;
 }
 
 void VideoCaptureManager::OnEnumerateDevices(MediaStreamType stream_type) {
   DCHECK(IsOnDeviceThread());
 
   media::VideoCaptureDevice::Names device_names;
   GetAvailableDevices(stream_type, &device_names);
 
@@ skipping 24 matching lines @@
     PostOnOpened(device.device.type, capture_session_id);
     return;
   }
 
   // Open the device.
   media::VideoCaptureDevice::Name vc_device_name;
   vc_device_name.device_name = device.device.name;
   vc_device_name.unique_id = device.device.id;
 
   if (use_fake_device_) {
+    const bool encoded_capture =
+        (device.device.type == MEDIA_SCREEN_ENCODED_VIDEO_CAPTURE);
     video_capture_device =
-        media::FakeVideoCaptureDevice::Create(vc_device_name);
+        media::FakeVideoCaptureDevice::Create(vc_device_name, encoded_capture);
   } else {
     switch (device.device.type) {
       case MEDIA_DEVICE_VIDEO_CAPTURE: {
         video_capture_device =
             media::VideoCaptureDevice::Create(vc_device_name);
         break;
       }
       case MEDIA_TAB_VIDEO_CAPTURE: {
         video_capture_device = WebContentsVideoCaptureDevice::Create(
             vc_device_name.unique_id);
@@ skipping 87 matching lines @@
   // Possible errors are signaled to video_capture_receiver by
   // video_capture_device. video_capture_receiver to perform actions.
   video_capture_device->Allocate(capture_params.width, capture_params.height,
                                  capture_params.frame_per_second,
                                  video_capture_receiver);
   video_capture_device->Start();
 }
 
 void VideoCaptureManager::OnStop(
     const media::VideoCaptureSessionId capture_session_id,
-    base::Closure stopped_cb) {
+    const base::Closure& stopped_cb) {
   DCHECK(IsOnDeviceThread());
   DVLOG(1) << "VideoCaptureManager::OnStop, id " << capture_session_id;
 
   VideoCaptureDevices::iterator it = devices_.find(capture_session_id);
   if (it != devices_.end()) {
     media::VideoCaptureDevice* video_capture_device = it->second.capture_device;
     // Possible errors are signaled to video_capture_receiver by
     // video_capture_device. video_capture_receiver to perform actions.
     video_capture_device->Stop();
     video_capture_device->DeAllocate();
     Controllers::iterator cit = controllers_.find(video_capture_device);
     if (cit != controllers_.end()) {
       cit->second->ready_to_delete = true;
       if (cit->second->handlers.empty()) {
         delete cit->second;
         controllers_.erase(cit);
       }
     }
   }
 
   if (!stopped_cb.is_null())
     stopped_cb.Run();
 
   if (capture_session_id == kStartOpenSessionId) {
     // This device was opened from Start(), not Open(). Close it!
     OnClose(capture_session_id);
   }
 }
 
+void VideoCaptureManager::OnTryConfigureEncodedBitstream(
+    const media::VideoCaptureSessionId& session_id,
+    const media::RuntimeVideoEncodingParameters& params) {
+  DCHECK(IsOnDeviceThread());
+  media::VideoCaptureDevice* video_capture_device =
+      GetDeviceInternal(session_id);
+  if (!video_capture_device)
+    return;
+  video_capture_device->TryConfigureEncodedBitstream(params);
+}
+
 void VideoCaptureManager::OnOpened(MediaStreamType stream_type,
                                    int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
   listener_->Opened(stream_type, capture_session_id);
 }
 
@@ skipping 77 matching lines @@
 void VideoCaptureManager::GetAvailableDevices(
     MediaStreamType stream_type,
     media::VideoCaptureDevice::Names* device_names) {
   DCHECK(IsOnDeviceThread());
 
   switch (stream_type) {
     case MEDIA_DEVICE_VIDEO_CAPTURE:
       if (!use_fake_device_) {
         media::VideoCaptureDevice::GetDeviceNames(device_names);
       } else {
-        media::FakeVideoCaptureDevice::GetDeviceNames(device_names);
+        media::FakeVideoCaptureDevice::GetDeviceNames(device_names, false);
       }
       break;
 
     case MEDIA_SCREEN_VIDEO_CAPTURE:
       device_names->clear();
       break;
 
+    case MEDIA_SCREEN_ENCODED_VIDEO_CAPTURE:
+      device_names->clear();
+      break;
+
     default:
       NOTREACHED();
       break;
   }
 }
 
 bool VideoCaptureManager::DeviceOpened(
     const media::VideoCaptureDevice::Name& device_name) {
   DCHECK(IsOnDeviceThread());
 
@@ skipping 32 matching lines @@
       // We've found the device!
       return true;
     }
   }
   return false;
 }
 
 void VideoCaptureManager::AddController(
     const media::VideoCaptureParams& capture_params,
     VideoCaptureControllerEventHandler* handler,
-    base::Callback<void(VideoCaptureController*)> added_cb) {
+    const base::Callback<void(VideoCaptureController*)>& added_cb) {
   DCHECK(handler);
   device_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::DoAddControllerOnDeviceThread,
                  this, capture_params, handler, added_cb));
 }
 
 void VideoCaptureManager::DoAddControllerOnDeviceThread(
     const media::VideoCaptureParams capture_params,
     VideoCaptureControllerEventHandler* handler,
-    base::Callback<void(VideoCaptureController*)> added_cb) {
+    const base::Callback<void(VideoCaptureController*)>& added_cb) {
   DCHECK(IsOnDeviceThread());
 
   media::VideoCaptureDevice* video_capture_device =
       GetDeviceInternal(capture_params.session_id);
   scoped_refptr<VideoCaptureController> controller;
   if (video_capture_device) {
     Controllers::iterator cit = controllers_.find(video_capture_device);
     if (cit == controllers_.end()) {
       controller = new VideoCaptureController(this);
       controllers_[video_capture_device] =
@@ skipping 34 matching lines @@
       }
       if (handlers.empty() && cit->second->ready_to_delete) {
         delete cit->second;
         controllers_.erase(cit);
       }
       return;
     }
   }
 }
 
+void VideoCaptureManager::RequestEncodingCapabilities(
+    const media::VideoCaptureSessionId& session_id,
+    const base::Callback<void(
+        const media::VideoEncodingCapabilities&)>& caps_cb) {
+  device_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &VideoCaptureManager::DoRequestEncodingCapabilitiesOnDeviceThread,
+          this,
+          session_id,
+          caps_cb));
+}
+
+void VideoCaptureManager::DoRequestEncodingCapabilitiesOnDeviceThread(
+    const media::VideoCaptureSessionId& session_id,
+    const base::Callback<void(
+        const media::VideoEncodingCapabilities&)>& caps_cb) {
+  DCHECK(IsOnDeviceThread());
+  media::VideoCaptureDevice* video_capture_device =
+      GetDeviceInternal(session_id);
+  if (!video_capture_device)
+    return;
+  caps_cb.Run(video_capture_device->GetEncodingCapabilities());
+}
+
 media::VideoCaptureDevice* VideoCaptureManager::GetDeviceInternal(
     int capture_session_id) {
   DCHECK(IsOnDeviceThread());
   VideoCaptureDevices::iterator dit = devices_.find(capture_session_id);
   if (dit != devices_.end()) {
     return dit->second.capture_device;
   }
 
   // Solution for not using MediaStreamManager.
   // This session id won't be returned by Open().
@@ skipping 13 matching lines @@
 
     VideoCaptureDevices::iterator dit = devices_.find(capture_session_id);
     if (dit != devices_.end()) {
       return dit->second.capture_device;
     }
   }
   return NULL;
 }
 
 }  // namespace content