New rtc::VideoSinkInterface.

talk/media/base/capturemanager_unittest.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 73 matching lines @@
 
   cricket::CaptureState capture_state_;
   int callback_count_;
   cricket::VideoFormat format_vga_;
   cricket::VideoFormat format_qvga_;
 };
 
 // Incorrect use cases.
 TEST_F(CaptureManagerTest, InvalidCallOrder) {
   // Capturer must be registered before any of these calls.
-  EXPECT_FALSE(capture_manager_.AddVideoRenderer(&video_capturer_,
-                                                 &video_renderer_));
+  EXPECT_FALSE(capture_manager_.AddVideoSink(&video_capturer_,
+                                             &video_renderer_));
 }
 
 TEST_F(CaptureManagerTest, InvalidAddingRemoving) {
   EXPECT_FALSE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                  cricket::VideoFormat()));
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_vga_));
   EXPECT_EQ_WAIT(cricket::CS_RUNNING, capture_state(), kMsCallbackWait);
   EXPECT_EQ(1, callback_count());
-  EXPECT_FALSE(capture_manager_.AddVideoRenderer(&video_capturer_, NULL));
+  EXPECT_FALSE(capture_manager_.AddVideoSink(&video_capturer_, NULL));
   EXPECT_TRUE(capture_manager_.StopVideoCapture(&video_capturer_, format_vga_));
 }
 
 // Valid use cases
 TEST_F(CaptureManagerTest, KeepFirstResolutionHigh) {
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_vga_));
   EXPECT_EQ_WAIT(cricket::CS_RUNNING, capture_state(), kMsCallbackWait);
   EXPECT_EQ(1, callback_count());
-  EXPECT_TRUE(capture_manager_.AddVideoRenderer(&video_capturer_,
-                                                &video_renderer_));
+  EXPECT_TRUE(capture_manager_.AddVideoSink(&video_capturer_,
+                                            &video_renderer_));
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(1, NumFramesRendered());
   // Renderer should be fed frames with the resolution of format_vga_.
   EXPECT_TRUE(WasRenderedResolution(format_vga_));
 
   // Start again with one more format.
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_qvga_));
   // Existing renderers should be fed frames with the resolution of format_vga_.
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_TRUE(WasRenderedResolution(format_vga_));
   EXPECT_TRUE(capture_manager_.StopVideoCapture(&video_capturer_, format_vga_));
   EXPECT_TRUE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                 format_qvga_));
   EXPECT_FALSE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                  format_vga_));
   EXPECT_FALSE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                  format_qvga_));
 }
 
 // Should pick the lowest resolution as the highest resolution is not chosen
 // until after capturing has started. This ensures that no particular resolution
 // is favored over others.
 TEST_F(CaptureManagerTest, KeepFirstResolutionLow) {
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_qvga_));
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_vga_));
-  EXPECT_TRUE(capture_manager_.AddVideoRenderer(&video_capturer_,
-                                                &video_renderer_));
+  EXPECT_TRUE(capture_manager_.AddVideoSink(&video_capturer_,
+                                            &video_renderer_));
   EXPECT_EQ_WAIT(1, callback_count(), kMsCallbackWait);
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(1, NumFramesRendered());
   EXPECT_TRUE(WasRenderedResolution(format_qvga_));
   EXPECT_TRUE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                 format_qvga_));
   EXPECT_TRUE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                 format_vga_));
 }
 
 // Ensure that the reference counting is working when multiple start and
 // multiple stop calls are made.
 TEST_F(CaptureManagerTest, MultipleStartStops) {
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_vga_));
   // Add video capturer but with different format.
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_qvga_));
   EXPECT_EQ_WAIT(cricket::CS_RUNNING, capture_state(), kMsCallbackWait);
   EXPECT_EQ(1, callback_count());
-  EXPECT_TRUE(capture_manager_.AddVideoRenderer(&video_capturer_,
-                                                &video_renderer_));
+  EXPECT_TRUE(capture_manager_.AddVideoSink(&video_capturer_,
+                                            &video_renderer_));
   // Ensure that a frame can be captured when two start calls have been made.
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(1, NumFramesRendered());
 
   EXPECT_TRUE(capture_manager_.StopVideoCapture(&video_capturer_, format_vga_));
   // Video should still render since there has been two start calls but only
   // one stop call.
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(2, NumFramesRendered());
 
   EXPECT_TRUE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                 format_qvga_));
   EXPECT_EQ_WAIT(cricket::CS_STOPPED, capture_state(), kMsCallbackWait);
   EXPECT_EQ(2, callback_count());
   // Last stop call should fail as it is one more than the number of start
   // calls.
   EXPECT_FALSE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                  format_vga_));
 }
 
 TEST_F(CaptureManagerTest, TestForceRestart) {
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_qvga_));
-  EXPECT_TRUE(capture_manager_.AddVideoRenderer(&video_capturer_,
-                                                &video_renderer_));
+  EXPECT_TRUE(capture_manager_.AddVideoSink(&video_capturer_,
+                                            &video_renderer_));
   EXPECT_EQ_WAIT(1, callback_count(), kMsCallbackWait);
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(1, NumFramesRendered());
   EXPECT_TRUE(WasRenderedResolution(format_qvga_));
   // Now restart with vga.
   EXPECT_TRUE(capture_manager_.RestartVideoCapture(
       &video_capturer_, format_qvga_, format_vga_,
       cricket::CaptureManager::kForceRestart));
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(2, NumFramesRendered());
   EXPECT_TRUE(WasRenderedResolution(format_vga_));
   EXPECT_TRUE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                 format_vga_));
 }
 
 TEST_F(CaptureManagerTest, TestRequestRestart) {
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_vga_));
-  EXPECT_TRUE(capture_manager_.AddVideoRenderer(&video_capturer_,
-                                                &video_renderer_));
+  EXPECT_TRUE(capture_manager_.AddVideoSink(&video_capturer_,
+                                            &video_renderer_));

[pthatcher1, 2016/01/27 01:11:03]

You can just remove all the expects on the return value of AddVideoSink.

[nisse-webrtc, 2016/01/27 09:08:51]

Done. I have no choice with a void return value...

   EXPECT_EQ_WAIT(1, callback_count(), kMsCallbackWait);
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(1, NumFramesRendered());
   EXPECT_TRUE(WasRenderedResolution(format_vga_));
   // Now request restart with qvga.
   EXPECT_TRUE(capture_manager_.RestartVideoCapture(
       &video_capturer_, format_vga_, format_qvga_,
       cricket::CaptureManager::kRequestRestart));
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(2, NumFramesRendered());
   EXPECT_TRUE(WasRenderedResolution(format_vga_));
   EXPECT_TRUE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                 format_qvga_));
 }