Replace calls to TimeMillis with Clock in video_capture_unittest As this is a sort of integration test, the use of an injected or simulated clock is not relevant. Bug: webrtc:42223992 Change-Id: I8291a4d5382958a17d6c1cd7fc42cbd35e2a5462 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/407420 Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Auto-Submit: Evan Shrubsole <eshr@webrtc.org> Commit-Queue: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/main@{#45512}
diff --git a/modules/video_capture/test/video_capture_unittest.cc b/modules/video_capture/test/video_capture_unittest.cc index c4c2c71..d763ff1 100644 --- a/modules/video_capture/test/video_capture_unittest.cc +++ b/modules/video_capture/test/video_capture_unittest.cc
@@ -28,16 +28,16 @@ #include "modules/video_capture/video_capture_factory.h" #include "rtc_base/checks.h" #include "rtc_base/synchronization/mutex.h" -#include "rtc_base/time_utils.h" +#include "system_wrappers/include/clock.h" #include "test/frame_utils.h" #include "test/gmock.h" #include "test/gtest.h" #include "test/wait_until.h" +namespace webrtc { +namespace { + using ::testing::Ge; -using webrtc::VideoCaptureCapability; -using webrtc::VideoCaptureFactory; -using webrtc::VideoCaptureModule; static const int kTimeOut = 5000; #ifdef WEBRTC_MAC @@ -46,22 +46,22 @@ static const int kTestFramerate = 30; #endif -class TestVideoCaptureCallback - : public webrtc::VideoSinkInterface<webrtc::VideoFrame> { +class TestVideoCaptureCallback : public VideoSinkInterface<webrtc::VideoFrame> { public: - TestVideoCaptureCallback() - : last_render_time_ms_(0), + explicit TestVideoCaptureCallback(Clock& clock) + : clock_(clock), + last_render_time_ms_(0), incoming_frames_(0), timing_warnings_(0), - rotate_frame_(webrtc::kVideoRotation_0) {} + rotate_frame_(kVideoRotation_0) {} ~TestVideoCaptureCallback() override { if (timing_warnings_ > 0) printf("No of timing warnings %d\n", timing_warnings_); } - void OnFrame(const webrtc::VideoFrame& videoFrame) override { - webrtc::MutexLock lock(&capture_lock_); + void OnFrame(const VideoFrame& videoFrame) override { + MutexLock lock(&capture_lock_); int height = videoFrame.height(); int width = videoFrame.width(); #if defined(WEBRTC_ANDROID) && WEBRTC_ANDROID @@ -75,8 +75,9 @@ EXPECT_EQ(rotate_frame_, videoFrame.rotation()); #endif // RenderTimstamp should be the time now. - EXPECT_TRUE(videoFrame.render_time_ms() >= webrtc::TimeMillis() - 30 && - videoFrame.render_time_ms() <= webrtc::TimeMillis()); + EXPECT_TRUE(videoFrame.render_time_ms() >= + clock_.TimeInMilliseconds() - 30 && + videoFrame.render_time_ms() <= clock_.TimeInMilliseconds()); if ((videoFrame.render_time_ms() > last_render_time_ms_ + (1000 * 1.1) / capability_.maxFPS && @@ -93,49 +94,50 @@ } void SetExpectedCapability(VideoCaptureCapability capability) { - webrtc::MutexLock lock(&capture_lock_); + MutexLock lock(&capture_lock_); capability_ = capability; incoming_frames_ = 0; last_render_time_ms_ = 0; } int incoming_frames() { - webrtc::MutexLock lock(&capture_lock_); + MutexLock lock(&capture_lock_); return incoming_frames_; } int timing_warnings() { - webrtc::MutexLock lock(&capture_lock_); + MutexLock lock(&capture_lock_); return timing_warnings_; } VideoCaptureCapability capability() { - webrtc::MutexLock lock(&capture_lock_); + MutexLock lock(&capture_lock_); return capability_; } - bool CompareLastFrame(const webrtc::VideoFrame& frame) { - webrtc::MutexLock lock(&capture_lock_); - return webrtc::test::FrameBufsEqual(last_frame_, - frame.video_frame_buffer()); + bool CompareLastFrame(const VideoFrame& frame) { + MutexLock lock(&capture_lock_); + return test::FrameBufsEqual(last_frame_, frame.video_frame_buffer()); } - void SetExpectedCaptureRotation(webrtc::VideoRotation rotation) { - webrtc::MutexLock lock(&capture_lock_); + void SetExpectedCaptureRotation(VideoRotation rotation) { + MutexLock lock(&capture_lock_); rotate_frame_ = rotation; } private: - webrtc::Mutex capture_lock_; + Mutex capture_lock_; VideoCaptureCapability capability_; + Clock& clock_; int64_t last_render_time_ms_; int incoming_frames_; int timing_warnings_; - webrtc::scoped_refptr<webrtc::VideoFrameBuffer> last_frame_; - webrtc::VideoRotation rotate_frame_; + scoped_refptr<webrtc::VideoFrameBuffer> last_frame_; + VideoRotation rotate_frame_; }; class VideoCaptureTest : public ::testing::Test { public: - VideoCaptureTest() : number_of_devices_(0) {} + VideoCaptureTest() + : clock_(*Clock::GetRealTimeClock()), number_of_devices_(0) {} void SetUp() override { device_info_.reset(VideoCaptureFactory::CreateDeviceInfo()); @@ -144,16 +146,16 @@ ASSERT_GT(number_of_devices_, 0u); } - webrtc::scoped_refptr<VideoCaptureModule> OpenVideoCaptureDevice( + scoped_refptr<VideoCaptureModule> OpenVideoCaptureDevice( unsigned int device, - webrtc::VideoSinkInterface<webrtc::VideoFrame>* callback) { + VideoSinkInterface<webrtc::VideoFrame>* callback) { char device_name[256]; char unique_name[256]; EXPECT_EQ(0, device_info_->GetDeviceName(device, device_name, 256, unique_name, 256)); - webrtc::scoped_refptr<VideoCaptureModule> module( + scoped_refptr<VideoCaptureModule> module( VideoCaptureFactory::Create(unique_name)); if (module.get() == nullptr) return nullptr; @@ -175,6 +177,7 @@ EXPECT_EQ(capability.height, resulting_capability.height); } + Clock& clock_; std::unique_ptr<VideoCaptureModule::DeviceInfo> device_info_; unsigned int number_of_devices_; }; @@ -188,9 +191,9 @@ #endif TEST_F(VideoCaptureTest, MAYBE_CreateDelete) { for (int i = 0; i < 5; ++i) { - int64_t start_time = webrtc::TimeMillis(); - TestVideoCaptureCallback capture_observer; - webrtc::scoped_refptr<VideoCaptureModule> module( + int64_t start_time = clock_.TimeInMilliseconds(); + TestVideoCaptureCallback capture_observer(clock_); + scoped_refptr<VideoCaptureModule> module( OpenVideoCaptureDevice(0, &capture_observer)); ASSERT_TRUE(module.get() != nullptr); @@ -201,26 +204,25 @@ capability.width = kTestWidth; capability.height = kTestHeight; capability.maxFPS = kTestFramerate; - capability.videoType = webrtc::VideoType::kUnknown; + capability.videoType = VideoType::kUnknown; #endif capture_observer.SetExpectedCapability(capability); ASSERT_NO_FATAL_FAILURE(StartCapture(module.get(), capability)); // Less than 4s to start the camera. - EXPECT_LE(webrtc::TimeMillis() - start_time, 4000); + EXPECT_LE(clock_.TimeInMilliseconds() - start_time, 4000); // Make sure 5 frames are captured. - EXPECT_THAT(webrtc::WaitUntil( - [&] { return capture_observer.incoming_frames(); }, Ge(5), - {.timeout = webrtc::TimeDelta::Millis(kTimeOut)}), - webrtc::IsRtcOk()); + EXPECT_THAT(WaitUntil([&] { return capture_observer.incoming_frames(); }, + Ge(5), {.timeout = TimeDelta::Millis(kTimeOut)}), + IsRtcOk()); - int64_t stop_time = webrtc::TimeMillis(); + int64_t stop_time = clock_.TimeInMilliseconds(); EXPECT_EQ(0, module->StopCapture()); EXPECT_FALSE(module->CaptureStarted()); // Less than 3s to stop the camera. - EXPECT_LE(webrtc::TimeMillis() - stop_time, 3000); + EXPECT_LE(clock_.TimeInMilliseconds() - stop_time, 3000); } } @@ -232,9 +234,9 @@ #define MAYBE_Capabilities Capabilities #endif TEST_F(VideoCaptureTest, MAYBE_Capabilities) { - TestVideoCaptureCallback capture_observer; + TestVideoCaptureCallback capture_observer(clock_); - webrtc::scoped_refptr<VideoCaptureModule> module( + scoped_refptr<VideoCaptureModule> module( OpenVideoCaptureDevice(0, &capture_observer)); ASSERT_TRUE(module.get() != nullptr); @@ -264,10 +266,9 @@ capture_observer.SetExpectedCapability(capability); ASSERT_NO_FATAL_FAILURE(StartCapture(module.get(), capability)); // Make sure at least one frame is captured. - EXPECT_THAT(webrtc::WaitUntil( - [&] { return capture_observer.incoming_frames(); }, Ge(1), - {.timeout = webrtc::TimeDelta::Millis(kTimeOut)}), - webrtc::IsRtcOk()); + EXPECT_THAT(WaitUntil([&] { return capture_observer.incoming_frames(); }, + Ge(1), {.timeout = TimeDelta::Millis(kTimeOut)}), + IsRtcOk()); EXPECT_EQ(0, module->StopCapture()); } @@ -297,8 +298,8 @@ return; } - TestVideoCaptureCallback capture_observer1; - webrtc::scoped_refptr<VideoCaptureModule> module1( + TestVideoCaptureCallback capture_observer1(clock_); + scoped_refptr<VideoCaptureModule> module1( OpenVideoCaptureDevice(0, &capture_observer1)); ASSERT_TRUE(module1.get() != nullptr); VideoCaptureCapability capability1; @@ -308,12 +309,12 @@ capability1.width = kTestWidth; capability1.height = kTestHeight; capability1.maxFPS = kTestFramerate; - capability1.videoType = webrtc::VideoType::kUnknown; + capability1.videoType = VideoType::kUnknown; #endif capture_observer1.SetExpectedCapability(capability1); - TestVideoCaptureCallback capture_observer2; - webrtc::scoped_refptr<VideoCaptureModule> module2( + TestVideoCaptureCallback capture_observer2(clock_); + scoped_refptr<VideoCaptureModule> module2( OpenVideoCaptureDevice(1, &capture_observer2)); ASSERT_TRUE(module1.get() != nullptr); @@ -324,20 +325,18 @@ capability2.width = kTestWidth; capability2.height = kTestHeight; capability2.maxFPS = kTestFramerate; - capability2.videoType = webrtc::VideoType::kUnknown; + capability2.videoType = VideoType::kUnknown; #endif capture_observer2.SetExpectedCapability(capability2); ASSERT_NO_FATAL_FAILURE(StartCapture(module1.get(), capability1)); ASSERT_NO_FATAL_FAILURE(StartCapture(module2.get(), capability2)); - EXPECT_THAT(webrtc::WaitUntil( - [&] { return capture_observer1.incoming_frames(); }, Ge(5), - {.timeout = webrtc::TimeDelta::Millis(kTimeOut)}), - webrtc::IsRtcOk()); - EXPECT_THAT(webrtc::WaitUntil( - [&] { return capture_observer2.incoming_frames(); }, Ge(5), - {.timeout = webrtc::TimeDelta::Millis(kTimeOut)}), - webrtc::IsRtcOk()); + EXPECT_THAT(WaitUntil([&] { return capture_observer1.incoming_frames(); }, + Ge(5), {.timeout = TimeDelta::Millis(kTimeOut)}), + IsRtcOk()); + EXPECT_THAT(WaitUntil([&] { return capture_observer2.incoming_frames(); }, + Ge(5), {.timeout = TimeDelta::Millis(kTimeOut)}), + IsRtcOk()); EXPECT_EQ(0, module2->StopCapture()); EXPECT_EQ(0, module1->StopCapture()); } @@ -349,34 +348,35 @@ #define MAYBE_ConcurrentAccess ConcurrentAccess #endif TEST_F(VideoCaptureTest, MAYBE_ConcurrentAccess) { - TestVideoCaptureCallback capture_observer1; - webrtc::scoped_refptr<VideoCaptureModule> module1( + TestVideoCaptureCallback capture_observer1(clock_); + scoped_refptr<VideoCaptureModule> module1( OpenVideoCaptureDevice(0, &capture_observer1)); ASSERT_TRUE(module1.get() != nullptr); VideoCaptureCapability capability; device_info_->GetCapability(module1->CurrentDeviceName(), 0, capability); capture_observer1.SetExpectedCapability(capability); - TestVideoCaptureCallback capture_observer2; - webrtc::scoped_refptr<VideoCaptureModule> module2( + TestVideoCaptureCallback capture_observer2(clock_); + scoped_refptr<VideoCaptureModule> module2( OpenVideoCaptureDevice(0, &capture_observer2)); ASSERT_TRUE(module2.get() != nullptr); capture_observer2.SetExpectedCapability(capability); // Starting module1 should work. ASSERT_NO_FATAL_FAILURE(StartCapture(module1.get(), capability)); - EXPECT_THAT(webrtc::WaitUntil( - [&] { return capture_observer1.incoming_frames(); }, Ge(5), - {.timeout = webrtc::TimeDelta::Millis(kTimeOut)}), - webrtc::IsRtcOk()); + EXPECT_THAT(WaitUntil([&] { return capture_observer1.incoming_frames(); }, + Ge(5), {.timeout = TimeDelta::Millis(kTimeOut)}), + IsRtcOk()); // When module1 is stopped, starting module2 for the same device should work. EXPECT_EQ(0, module1->StopCapture()); ASSERT_NO_FATAL_FAILURE(StartCapture(module2.get(), capability)); - EXPECT_THAT(webrtc::WaitUntil( - [&] { return capture_observer2.incoming_frames(); }, Ge(5), - {.timeout = webrtc::TimeDelta::Millis(kTimeOut)}), - webrtc::IsRtcOk()); + EXPECT_THAT(WaitUntil([&] { return capture_observer2.incoming_frames(); }, + Ge(5), {.timeout = TimeDelta::Millis(kTimeOut)}), + IsRtcOk()); EXPECT_EQ(0, module2->StopCapture()); } + +} // namespace +} // namespace webrtc