OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "remoting/protocol/capture_scheduler.h" | 5 #include "remoting/protocol/capture_scheduler.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
11 #include "base/macros.h" | 11 #include "base/macros.h" |
| 12 #include "base/memory/ptr_util.h" |
12 #include "base/message_loop/message_loop.h" | 13 #include "base/message_loop/message_loop.h" |
13 #include "base/test/simple_test_tick_clock.h" | 14 #include "base/test/simple_test_tick_clock.h" |
14 #include "base/timer/mock_timer.h" | 15 #include "base/timer/mock_timer.h" |
15 #include "remoting/proto/video.pb.h" | 16 #include "remoting/proto/video.pb.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 17 #include "testing/gtest/include/gtest/gtest.h" |
17 | 18 |
18 namespace remoting { | 19 namespace remoting { |
19 namespace protocol { | 20 namespace protocol { |
20 | 21 |
21 static const int kTestInputs[] = { 100, 50, 30, 20, 10, 30, 60, 80 }; | 22 static const int kTestInputs[] = { 100, 50, 30, 20, 10, 30, 60, 80 }; |
22 static const int kMinumumFrameIntervalMs = 50; | 23 static const int kMinumumFrameIntervalMs = 50; |
23 | 24 |
24 class CaptureSchedulerTest : public testing::Test { | 25 class CaptureSchedulerTest : public testing::Test { |
25 public: | 26 public: |
26 CaptureSchedulerTest() : capture_called_(false) {} | 27 CaptureSchedulerTest() : capture_called_(false) {} |
27 | 28 |
28 void InitScheduler() { | 29 void InitScheduler() { |
29 scheduler_.reset(new CaptureScheduler( | 30 scheduler_.reset(new CaptureScheduler( |
30 base::Bind(&CaptureSchedulerTest::DoCapture, base::Unretained(this)))); | 31 base::Bind(&CaptureSchedulerTest::DoCapture, base::Unretained(this)))); |
31 scheduler_->set_minimum_interval( | 32 scheduler_->set_minimum_interval( |
32 base::TimeDelta::FromMilliseconds(kMinumumFrameIntervalMs)); | 33 base::TimeDelta::FromMilliseconds(kMinumumFrameIntervalMs)); |
33 tick_clock_ = new base::SimpleTestTickClock(); | 34 tick_clock_ = new base::SimpleTestTickClock(); |
34 scheduler_->SetTickClockForTest(make_scoped_ptr(tick_clock_)); | 35 scheduler_->SetTickClockForTest(base::WrapUnique(tick_clock_)); |
35 capture_timer_ = new base::MockTimer(false, false); | 36 capture_timer_ = new base::MockTimer(false, false); |
36 scheduler_->SetTimerForTest(make_scoped_ptr(capture_timer_)); | 37 scheduler_->SetTimerForTest(base::WrapUnique(capture_timer_)); |
37 scheduler_->Start(); | 38 scheduler_->Start(); |
38 } | 39 } |
39 | 40 |
40 void DoCapture() { | 41 void DoCapture() { |
41 capture_called_ = true; | 42 capture_called_ = true; |
42 } | 43 } |
43 | 44 |
44 void CheckCaptureCalled() { | 45 void CheckCaptureCalled() { |
45 EXPECT_TRUE(capture_called_); | 46 EXPECT_TRUE(capture_called_); |
46 capture_called_ = false; | 47 capture_called_ = false; |
47 } | 48 } |
48 | 49 |
49 void SimulateSingleFrameCapture( | 50 void SimulateSingleFrameCapture( |
50 base::TimeDelta capture_delay, | 51 base::TimeDelta capture_delay, |
51 base::TimeDelta encode_delay, | 52 base::TimeDelta encode_delay, |
52 base::TimeDelta expected_delay_between_frames) { | 53 base::TimeDelta expected_delay_between_frames) { |
53 capture_timer_->Fire(); | 54 capture_timer_->Fire(); |
54 CheckCaptureCalled(); | 55 CheckCaptureCalled(); |
55 tick_clock_->Advance(capture_delay); | 56 tick_clock_->Advance(capture_delay); |
56 scheduler_->OnCaptureCompleted(); | 57 scheduler_->OnCaptureCompleted(); |
57 | 58 |
58 VideoPacket packet; | 59 VideoPacket packet; |
59 packet.set_encode_time_ms(encode_delay.InMilliseconds()); | 60 packet.set_encode_time_ms(encode_delay.InMilliseconds()); |
60 scheduler_->OnFrameEncoded(&packet); | 61 scheduler_->OnFrameEncoded(&packet); |
61 | 62 |
62 scheduler_->OnFrameSent(); | 63 scheduler_->OnFrameSent(); |
63 | 64 |
64 scoped_ptr<VideoAck> ack(new VideoAck()); | 65 std::unique_ptr<VideoAck> ack(new VideoAck()); |
65 ack->set_frame_id(packet.frame_id()); | 66 ack->set_frame_id(packet.frame_id()); |
66 scheduler_->ProcessVideoAck(std::move(ack)); | 67 scheduler_->ProcessVideoAck(std::move(ack)); |
67 | 68 |
68 EXPECT_TRUE(capture_timer_->IsRunning()); | 69 EXPECT_TRUE(capture_timer_->IsRunning()); |
69 EXPECT_EQ(std::max(base::TimeDelta(), | 70 EXPECT_EQ(std::max(base::TimeDelta(), |
70 expected_delay_between_frames - capture_delay), | 71 expected_delay_between_frames - capture_delay), |
71 capture_timer_->GetCurrentDelay()); | 72 capture_timer_->GetCurrentDelay()); |
72 } | 73 } |
73 | 74 |
74 protected: | 75 protected: |
75 base::MessageLoop message_loop_; | 76 base::MessageLoop message_loop_; |
76 | 77 |
77 scoped_ptr<CaptureScheduler> scheduler_; | 78 std::unique_ptr<CaptureScheduler> scheduler_; |
78 | 79 |
79 // Owned by |scheduler_|. | 80 // Owned by |scheduler_|. |
80 base::SimpleTestTickClock* tick_clock_; | 81 base::SimpleTestTickClock* tick_clock_; |
81 base::MockTimer* capture_timer_; | 82 base::MockTimer* capture_timer_; |
82 | 83 |
83 bool capture_called_; | 84 bool capture_called_; |
84 }; | 85 }; |
85 | 86 |
86 TEST_F(CaptureSchedulerTest, SingleSampleSameTimes) { | 87 TEST_F(CaptureSchedulerTest, SingleSampleSameTimes) { |
87 const int kTestResults[][arraysize(kTestInputs)] = { | 88 const int kTestResults[][arraysize(kTestInputs)] = { |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
187 CheckCaptureCalled(); | 188 CheckCaptureCalled(); |
188 scheduler_->OnCaptureCompleted(); | 189 scheduler_->OnCaptureCompleted(); |
189 VideoPacket packet; | 190 VideoPacket packet; |
190 scheduler_->OnFrameEncoded(&packet); | 191 scheduler_->OnFrameEncoded(&packet); |
191 scheduler_->OnFrameSent(); | 192 scheduler_->OnFrameSent(); |
192 } | 193 } |
193 | 194 |
194 // Next frame should be scheduled, once one of the queued frames is | 195 // Next frame should be scheduled, once one of the queued frames is |
195 // acknowledged. | 196 // acknowledged. |
196 EXPECT_FALSE(capture_timer_->IsRunning()); | 197 EXPECT_FALSE(capture_timer_->IsRunning()); |
197 scheduler_->ProcessVideoAck(make_scoped_ptr(new VideoAck())); | 198 scheduler_->ProcessVideoAck(base::WrapUnique(new VideoAck())); |
198 EXPECT_TRUE(capture_timer_->IsRunning()); | 199 EXPECT_TRUE(capture_timer_->IsRunning()); |
199 } | 200 } |
200 | 201 |
201 } // namespace protocol | 202 } // namespace protocol |
202 } // namespace remoting | 203 } // namespace remoting |
OLD | NEW |