Hook up EncodedVideoSource on the browser side

content/browser/renderer_host/media/video_capture_controller_unittest.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.
 
 // Unit test for VideoCaptureController.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #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"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::InSequence;
 using ::testing::Return;
 
 namespace content {
 
 enum { kDeviceId = 1 };
 
 ACTION_P4(StopCapture, controller, controller_id, controller_handler,
           message_loop) {
   message_loop->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureController::StopCapture,
                  controller, controller_id, controller_handler));
   message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 }
 
 ACTION_P3(StopSession, controller, session_id, message_loop) {
   message_loop->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureController::StopSession,
                  controller, session_id));
   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:
   MockVideoCaptureControllerEventHandler(VideoCaptureController* controller,
                                          base::MessageLoop* message_loop)
       : controller_(controller),
         message_loop_(message_loop),
         controller_id_(kDeviceId),
         process_handle_(base::kNullProcessHandle) {
   }
   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,
         base::Bind(&VideoCaptureController::ReturnBuffer,
                    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);
   }
 
   scoped_refptr<VideoCaptureController> controller_;
   base::MessageLoop* message_loop_;
   VideoCaptureControllerID controller_id_;
   base::ProcessHandle process_handle_;
 };
 
 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,
                                     vc_receiver);
     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() {}
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureManager);
 };
 
 // Test class.
 class VideoCaptureControllerTest : public testing::Test {
  public:
   VideoCaptureControllerTest() {}
@@ skipping 37 matching lines @@
 
   InSequence s;
   EXPECT_CALL(*vcm_.get(),
               StartCapture(capture_params.width,
                            capture_params.height,
                            controller_.get())).Times(1);
   EXPECT_CALL(*controller_handler_,
               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(),
                             controller_handler_->controller_id_,
                             controller_handler_.get(),
                             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_,
                             capture_params);
   message_loop_->Run();
 }
 
 // Try to stop session before stopping capture.
 TEST_F(VideoCaptureControllerTest, StopSession) {
   media::VideoCaptureParams capture_params;
   capture_params.session_id = vcm_->video_session_id_;
   capture_params.width = 320;
   capture_params.height = 240;
   capture_params.frame_per_second = 30;
 
   InSequence s;
   EXPECT_CALL(*vcm_.get(),
               StartCapture(capture_params.width,
                            capture_params.height,
                            controller_.get())).Times(1);
   EXPECT_CALL(*controller_handler_,
               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(),
                             vcm_->video_session_id_,
                             message_loop_.get()));
   EXPECT_CALL(*controller_handler_,
               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_,
                             capture_params);
   message_loop_->Run();
 
   // The session is stopped now. There should be no buffer coming from
   // controller.
   EXPECT_CALL(*controller_handler_,
               DoBufferReady(controller_handler_->controller_id_))
       .Times(0);
   message_loop_->PostDelayedTask(FROM_HERE,
       base::MessageLoop::QuitClosure(), base::TimeDelta::FromSeconds(1));
   message_loop_->Run();
 
   EXPECT_CALL(*vcm_.get(), StopCapture(vcm_->video_session_id_)).Times(1);
   controller_->StopCapture(controller_handler_->controller_id_,
                            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