Index: remoting/host/capture_scheduler_unittest.cc |
diff --git a/remoting/host/capture_scheduler_unittest.cc b/remoting/host/capture_scheduler_unittest.cc |
deleted file mode 100644 |
index 7b6982ff80875b272365af7853d91383d7a91c0d..0000000000000000000000000000000000000000 |
--- a/remoting/host/capture_scheduler_unittest.cc |
+++ /dev/null |
@@ -1,195 +0,0 @@ |
-// Copyright 2013 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 "remoting/host/capture_scheduler.h" |
- |
-#include "base/message_loop/message_loop.h" |
-#include "base/test/simple_test_tick_clock.h" |
-#include "base/timer/mock_timer.h" |
-#include "remoting/proto/video.pb.h" |
-#include "testing/gtest/include/gtest/gtest.h" |
- |
-namespace remoting { |
- |
-static const int kTestInputs[] = { 100, 50, 30, 20, 10, 30, 60, 80 }; |
-static const int kMinumumFrameIntervalMs = 50; |
- |
-class CaptureSchedulerTest : public testing::Test { |
- public: |
- CaptureSchedulerTest() : capture_called_(false) {} |
- |
- void InitScheduler() { |
- scheduler_.reset(new CaptureScheduler( |
- base::Bind(&CaptureSchedulerTest::DoCapture, base::Unretained(this)))); |
- scheduler_->set_minimum_interval( |
- base::TimeDelta::FromMilliseconds(kMinumumFrameIntervalMs)); |
- tick_clock_ = new base::SimpleTestTickClock(); |
- scheduler_->SetTickClockForTest(make_scoped_ptr(tick_clock_)); |
- capture_timer_ = new base::MockTimer(false, false); |
- scheduler_->SetTimerForTest(make_scoped_ptr(capture_timer_)); |
- scheduler_->Start(); |
- } |
- |
- void DoCapture() { |
- capture_called_ = true; |
- } |
- |
- void CheckCaptureCalled() { |
- EXPECT_TRUE(capture_called_); |
- capture_called_ = false; |
- } |
- |
- void SimulateSingleFrameCapture( |
- base::TimeDelta capture_delay, |
- base::TimeDelta encode_delay, |
- base::TimeDelta expected_delay_between_frames) { |
- capture_timer_->Fire(); |
- CheckCaptureCalled(); |
- tick_clock_->Advance(capture_delay); |
- scheduler_->OnCaptureCompleted(); |
- |
- VideoPacket packet; |
- packet.set_encode_time_ms(encode_delay.InMilliseconds()); |
- scheduler_->OnFrameEncoded(&packet); |
- |
- scheduler_->OnFrameSent(); |
- |
- scoped_ptr<VideoAck> ack(new VideoAck()); |
- ack->set_frame_id(packet.frame_id()); |
- scheduler_->ProcessVideoAck(ack.Pass()); |
- |
- EXPECT_TRUE(capture_timer_->IsRunning()); |
- EXPECT_EQ(std::max(base::TimeDelta(), |
- expected_delay_between_frames - capture_delay), |
- capture_timer_->GetCurrentDelay()); |
- } |
- |
- protected: |
- base::MessageLoop message_loop_; |
- |
- scoped_ptr<CaptureScheduler> scheduler_; |
- |
- // Owned by |scheduler_|. |
- base::SimpleTestTickClock* tick_clock_; |
- base::MockTimer* capture_timer_; |
- |
- bool capture_called_; |
-}; |
- |
-TEST_F(CaptureSchedulerTest, SingleSampleSameTimes) { |
- const int kTestResults[][arraysize(kTestInputs)] = { |
- { 400, 200, 120, 80, 50, 120, 240, 320 }, // One core. |
- { 200, 100, 60, 50, 50, 60, 120, 160 }, // Two cores. |
- { 100, 50, 50, 50, 50, 50, 60, 80 }, // Four cores. |
- { 50, 50, 50, 50, 50, 50, 50, 50 } // Eight cores. |
- }; |
- |
- for (size_t i = 0; i < arraysize(kTestResults); ++i) { |
- for (size_t j = 0; j < arraysize(kTestInputs); ++j) { |
- InitScheduler(); |
- scheduler_->SetNumOfProcessorsForTest(1 << i); |
- |
- SimulateSingleFrameCapture( |
- base::TimeDelta::FromMilliseconds(kTestInputs[j]), |
- base::TimeDelta::FromMilliseconds(kTestInputs[j]), |
- base::TimeDelta::FromMilliseconds(kTestResults[i][j])); |
- } |
- } |
-} |
- |
-TEST_F(CaptureSchedulerTest, SingleSampleDifferentTimes) { |
- const int kTestResults[][arraysize(kTestInputs)] = { |
- { 360, 220, 120, 60, 60, 120, 220, 360 }, // One core. |
- { 180, 110, 60, 50, 50, 60, 110, 180 }, // Two cores. |
- { 90, 55, 50, 50, 50, 50, 55, 90 }, // Four cores. |
- { 50, 50, 50, 50, 50, 50, 50, 50 } // Eight cores. |
- }; |
- |
- for (size_t i = 0; i < arraysize(kTestResults); ++i) { |
- for (size_t j = 0; j < arraysize(kTestInputs); ++j) { |
- InitScheduler(); |
- scheduler_->SetNumOfProcessorsForTest(1 << i); |
- |
- SimulateSingleFrameCapture( |
- base::TimeDelta::FromMilliseconds(kTestInputs[j]), |
- base::TimeDelta::FromMilliseconds( |
- kTestInputs[arraysize(kTestInputs) - 1 - j]), |
- base::TimeDelta::FromMilliseconds(kTestResults[i][j])); |
- } |
- } |
-} |
- |
-TEST_F(CaptureSchedulerTest, RollingAverageDifferentTimes) { |
- const int kTestResults[][arraysize(kTestInputs)] = { |
- { 360, 290, 233, 133, 80, 80, 133, 233 }, // One core. |
- { 180, 145, 116, 66, 50, 50, 66, 116 }, // Two cores. |
- { 90, 72, 58, 50, 50, 50, 50, 58 }, // Four cores. |
- { 50, 50, 50, 50, 50, 50, 50, 50 } // Eight cores. |
- }; |
- |
- for (size_t i = 0; i < arraysize(kTestResults); ++i) { |
- InitScheduler(); |
- scheduler_->SetNumOfProcessorsForTest(1 << i); |
- for (size_t j = 0; j < arraysize(kTestInputs); ++j) { |
- SimulateSingleFrameCapture( |
- base::TimeDelta::FromMilliseconds(kTestInputs[j]), |
- base::TimeDelta::FromMilliseconds( |
- kTestInputs[arraysize(kTestInputs) - 1 - j]), |
- base::TimeDelta::FromMilliseconds(kTestResults[i][j])); |
- } |
- } |
-} |
- |
-// Verify that we never have more than 2 encoding frames. |
-TEST_F(CaptureSchedulerTest, MaximumEncodingFrames) { |
- InitScheduler(); |
- |
- // Process the first frame to let the scheduler know that receiver supports |
- // ACKs. |
- SimulateSingleFrameCapture( |
- base::TimeDelta(), base::TimeDelta(), |
- base::TimeDelta::FromMilliseconds(kMinumumFrameIntervalMs)); |
- |
- capture_timer_->Fire(); |
- CheckCaptureCalled(); |
- scheduler_->OnCaptureCompleted(); |
- |
- capture_timer_->Fire(); |
- CheckCaptureCalled(); |
- scheduler_->OnCaptureCompleted(); |
- |
- EXPECT_FALSE(capture_timer_->IsRunning()); |
- VideoPacket packet; |
- scheduler_->OnFrameEncoded(&packet); |
- EXPECT_TRUE(capture_timer_->IsRunning()); |
-} |
- |
-// Verify that the scheduler doesn't exceed maximum number of pending frames. |
-TEST_F(CaptureSchedulerTest, MaximumPendingFrames) { |
- InitScheduler(); |
- |
- // Process the first frame to let the scheduler know that receiver supports |
- // ACKs. |
- SimulateSingleFrameCapture( |
- base::TimeDelta(), base::TimeDelta(), |
- base::TimeDelta::FromMilliseconds(kMinumumFrameIntervalMs)); |
- |
- // Queue some frames until the sender is blocked. |
- while (capture_timer_->IsRunning()) { |
- capture_timer_->Fire(); |
- CheckCaptureCalled(); |
- scheduler_->OnCaptureCompleted(); |
- VideoPacket packet; |
- scheduler_->OnFrameEncoded(&packet); |
- scheduler_->OnFrameSent(); |
- } |
- |
- // Next frame should be scheduled, once one of the queued frames is |
- // acknowledged. |
- EXPECT_FALSE(capture_timer_->IsRunning()); |
- scheduler_->ProcessVideoAck(make_scoped_ptr(new VideoAck())); |
- EXPECT_TRUE(capture_timer_->IsRunning()); |
-} |
- |
-} // namespace remoting |