Hook up EncodedVideoSource on the browser side

content/browser/renderer_host/media/video_capture_controller_unittest.cc

Index: content/browser/renderer_host/media/video_capture_controller_unittest.cc
diff --git a/content/browser/renderer_host/media/video_capture_controller_unittest.cc b/content/browser/renderer_host/media/video_capture_controller_unittest.cc
index bc67fe4022f191109f847d34087683ceabc6acd9..530bf71d905d131c3ed7fd3d42417e087a3e2720 100644
--- a/content/browser/renderer_host/media/video_capture_controller_unittest.cc
+++ b/content/browser/renderer_host/media/video_capture_controller_unittest.cc
@@ -18,6 +18,7 @@
 #include "content/common/media/media_stream_options.h"
 #include "media/video/capture/fake_video_capture_device.h"
 #include "media/video/capture/video_capture_device.h"
+#include "media/video/video_encode_types.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -46,6 +47,12 @@ ACTION_P3(StopSession, controller, session_id, message_loop) {
   message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 }
 
+ACTION_P3(TryConfigureEncodedBitstream, controller, params, message_loop) {
+  message_loop->PostTask(FROM_HERE,
+      base::Bind(&VideoCaptureController::TryConfigureEncodedBitstream,
+                 controller, params));
+}
+
 class MockVideoCaptureControllerEventHandler
     : public VideoCaptureControllerEventHandler {
  public:
@@ -58,21 +65,19 @@ class MockVideoCaptureControllerEventHandler
   }
   virtual ~MockVideoCaptureControllerEventHandler() {}
 
-  MOCK_METHOD1(DoBufferCreated, void(const VideoCaptureControllerID&));
   MOCK_METHOD1(DoBufferReady, void(const VideoCaptureControllerID&));
   MOCK_METHOD1(DoFrameInfo, void(const VideoCaptureControllerID&));
+  MOCK_METHOD1(DoEncodedFrameInfo, void(const VideoCaptureControllerID&));
+  MOCK_METHOD1(DoBitstreamConfigChanged,
+               void(const VideoCaptureControllerID& id));
   MOCK_METHOD1(DoEnded, void(const VideoCaptureControllerID&));
 
   virtual void OnError(const VideoCaptureControllerID& id) OVERRIDE {}
-  virtual void OnBufferCreated(const VideoCaptureControllerID& id,
-                               base::SharedMemoryHandle handle,
-                               int length, int buffer_id) OVERRIDE {
-    EXPECT_EQ(id, controller_id_);
-    DoBufferCreated(id);
-  }
   virtual void OnBufferReady(const VideoCaptureControllerID& id,
                              int buffer_id,
-                             base::Time timestamp) OVERRIDE {
+                             size_t size,
+                             base::Time timestamp,
+                             bool key_frame) OVERRIDE {
     EXPECT_EQ(id, controller_id_);
     DoBufferReady(id);
     message_loop_->PostTask(FROM_HERE,
@@ -80,12 +85,26 @@ class MockVideoCaptureControllerEventHandler
                    controller_, controller_id_, this, buffer_id));
   }
   virtual void OnFrameInfo(const VideoCaptureControllerID& id,
-                           int width,
-                           int height,
-                           int frame_per_second) OVERRIDE {
+                           const media::VideoCaptureParams& params,
+                           const std::vector<base::SharedMemoryHandle>& buffers,
+                           size_t buffer_size) OVERRIDE {
     EXPECT_EQ(id, controller_id_);
     DoFrameInfo(id);
   }
+  virtual void OnEncodedFrameInfo(
+      const VideoCaptureControllerID& id,
+      const media::VideoEncodingParameters& params,
+      const std::vector<base::SharedMemoryHandle>& buffers,
+      size_t buffer_size) OVERRIDE {
+    EXPECT_EQ(id, controller_id_);
+    DoEncodedFrameInfo(id);
+  }
+  virtual void OnBitstreamConfigChanged(
+    const VideoCaptureControllerID& id,
+    const media::RuntimeVideoEncodingParameters& params) OVERRIDE {
+    EXPECT_EQ(id, controller_id_);
+    DoBitstreamConfigChanged(id);
+  }
   virtual void OnEnded(const VideoCaptureControllerID& id) OVERRIDE {
     EXPECT_EQ(id, controller_id_);
     DoEnded(id);
@@ -100,23 +119,31 @@ class MockVideoCaptureControllerEventHandler
 class MockVideoCaptureManager : public VideoCaptureManager {
  public:
   MockVideoCaptureManager()
-      : video_session_id_(kStartOpenSessionId) {}
+      : video_session_id_(kStartOpenSessionId),
+        encoded_capture_(false) {}
 
   void Init() {
     device_name_.unique_id = "/dev/video0";
     device_name_.device_name = "fake_device_0";
-
-    video_capture_device_.reset(
-        media::FakeVideoCaptureDevice::Create(device_name_));
-    ASSERT_TRUE(video_capture_device_.get() != NULL);
   }
 
   MOCK_METHOD3(StartCapture, void(int, int,
       media::VideoCaptureDevice::EventHandler*));
   MOCK_METHOD1(StopCapture, void(const media::VideoCaptureSessionId&));
 
-  void Start(const media::VideoCaptureParams& capture_params,
+  // Stub MediaStreamProviderListener implementation
+  virtual void Opened(MediaStreamType, int) OVERRIDE {}
+  virtual void Closed(MediaStreamType, int) OVERRIDE {}
+  virtual void DevicesEnumerated(MediaStreamType,
+                                 const StreamDeviceInfoArray&) OVERRIDE {}
+  virtual void Error(MediaStreamType, int, MediaStreamProviderError) OVERRIDE {}
+
+  virtual void Start(const media::VideoCaptureParams& capture_params,
              media::VideoCaptureDevice::EventHandler* vc_receiver) OVERRIDE {
+    video_capture_device_.reset(
+        media::FakeVideoCaptureDevice::Create(device_name_, encoded_capture_));
+    ASSERT_TRUE(video_capture_device_.get() != NULL);
+
     StartCapture(capture_params.width, capture_params.height, vc_receiver);
     video_capture_device_->Allocate(capture_params.width, capture_params.height,
                                     capture_params.frame_per_second,
@@ -124,16 +151,27 @@ class MockVideoCaptureManager : public VideoCaptureManager {
     video_capture_device_->Start();
   }
 
-  void Stop(const media::VideoCaptureSessionId& capture_session_id,
-            base::Closure stopped_cb) OVERRIDE {
+  virtual void Stop(const media::VideoCaptureSessionId& capture_session_id,
+            const base::Closure& stopped_cb) OVERRIDE {
     StopCapture(capture_session_id);
     video_capture_device_->Stop();
     video_capture_device_->DeAllocate();
   }
 
+  virtual void TryConfigureEncodedBitstream(
+    const media::VideoCaptureSessionId& session_id,
+    const media::RuntimeVideoEncodingParameters& params) OVERRIDE {
+    video_capture_device_->TryConfigureEncodedBitstream(params);
+  }
+
+  void SetEncodedCapture(bool encoded_capture) {
+    encoded_capture_ = encoded_capture;
+  }
+
   int video_session_id_;
   media::VideoCaptureDevice::Name device_name_;
   scoped_ptr<media::VideoCaptureDevice> video_capture_device_;
+  bool encoded_capture_;
 
  private:
   virtual ~MockVideoCaptureManager() {}
@@ -191,9 +229,6 @@ TEST_F(VideoCaptureControllerTest, StartAndStop) {
               DoFrameInfo(controller_handler_->controller_id_))
       .Times(AtLeast(1));
   EXPECT_CALL(*controller_handler_,
-              DoBufferCreated(controller_handler_->controller_id_))
-      .Times(AtLeast(1));
-  EXPECT_CALL(*controller_handler_,
               DoBufferReady(controller_handler_->controller_id_))
       .Times(AtLeast(1))
       .WillOnce(StopCapture(controller_.get(),
@@ -202,6 +237,14 @@ TEST_F(VideoCaptureControllerTest, StartAndStop) {
                             message_loop_.get()));
   EXPECT_CALL(*vcm_.get(), StopCapture(vcm_->video_session_id_)).Times(1);
 
+  // The encoded bitstream functions should not get called.
+  EXPECT_CALL(*controller_handler_,
+              DoEncodedFrameInfo(controller_handler_->controller_id_))
+      .Times(0);
+  EXPECT_CALL(*controller_handler_,
+              DoBitstreamConfigChanged(controller_handler_->controller_id_))
+      .Times(0);
+
   controller_->StartCapture(controller_handler_->controller_id_,
                             controller_handler_.get(),
                             controller_handler_->process_handle_,
@@ -226,9 +269,6 @@ TEST_F(VideoCaptureControllerTest, StopSession) {
               DoFrameInfo(controller_handler_->controller_id_))
       .Times(AtLeast(1));
   EXPECT_CALL(*controller_handler_,
-              DoBufferCreated(controller_handler_->controller_id_))
-      .Times(AtLeast(1));
-  EXPECT_CALL(*controller_handler_,
               DoBufferReady(controller_handler_->controller_id_))
       .Times(AtLeast(1))
       .WillOnce(StopSession(controller_.get(),
@@ -238,6 +278,14 @@ TEST_F(VideoCaptureControllerTest, StopSession) {
               DoEnded(controller_handler_->controller_id_))
       .Times(1);
 
+  // The encoded bitstream functions should not get called.
+  EXPECT_CALL(*controller_handler_,
+              DoEncodedFrameInfo(controller_handler_->controller_id_))
+      .Times(0);
+  EXPECT_CALL(*controller_handler_,
+              DoBitstreamConfigChanged(controller_handler_->controller_id_))
+      .Times(0);
+
   controller_->StartCapture(controller_handler_->controller_id_,
                             controller_handler_.get(),
                             controller_handler_->process_handle_,
@@ -258,4 +306,60 @@ TEST_F(VideoCaptureControllerTest, StopSession) {
                            controller_handler_.get());
 }
 
+// Check encoded capturing.
+TEST_F(VideoCaptureControllerTest, EncodedCapture) {
+  vcm_->SetEncodedCapture(true);
+  media::VideoEncodingParameters encoding_params;
+  encoding_params.codec_name = std::string("VP8");
+  encoding_params.resolution.SetSize(640, 480);
+  encoding_params.frames_per_second = 30;
+  encoding_params.runtime_params.average_bitrate = 1024;
+  encoding_params.runtime_params.max_bitrate = 1024;
+
+  media::RuntimeVideoEncodingParameters params;
+  params.average_bitrate = 1024;
+  params.max_bitrate = 1024;
+
+  InSequence s;
+  EXPECT_CALL(*vcm_.get(),
+              StartCapture(encoding_params.resolution.width(),
+                           encoding_params.resolution.height(),
+                           controller_.get())).Times(1);
+  EXPECT_CALL(*controller_handler_,
+              DoEncodedFrameInfo(controller_handler_->controller_id_))
+      .Times(AtLeast(1));
+  EXPECT_CALL(*controller_handler_,
+              DoBufferReady(controller_handler_->controller_id_))
+      .Times(AtLeast(1))
+      .WillOnce(TryConfigureEncodedBitstream(controller_.get(),
+                                             params,
+                                             message_loop_.get()));
+
+  EXPECT_CALL(*controller_handler_,
+              DoBitstreamConfigChanged(controller_handler_->controller_id_))
+      .Times(1)
+      .WillOnce(StopCapture(controller_.get(),
+                            controller_handler_->controller_id_,
+                            controller_handler_.get(),
+                            message_loop_.get()));
+
+  EXPECT_CALL(*vcm_.get(), StopCapture(vcm_->video_session_id_)).Times(1);
+
+  // The unencoded bitstream functions should not get called.
+  EXPECT_CALL(*controller_handler_,
+              DoFrameInfo(controller_handler_->controller_id_))
+      .Times(0);
+
+  media::VideoCaptureParams capture_params;
+  capture_params.session_id = vcm_->video_session_id_;
+  capture_params.width = encoding_params.resolution.width();
+  capture_params.height = encoding_params.resolution.height();
+  capture_params.frame_per_second = encoding_params.frames_per_second;
+  controller_->StartCapture(controller_handler_->controller_id_,
+                            controller_handler_.get(),
+                            controller_handler_->process_handle_,
+                            capture_params);
+  message_loop_->Run();
+}
+
 }  // namespace content