OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 | 7 |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
11 #include "base/macros.h" | 11 #include "base/macros.h" |
12 #include "base/memory/scoped_ptr.h" | 12 #include "base/memory/ptr_util.h" |
13 #include "base/test/simple_test_tick_clock.h" | 13 #include "base/test/simple_test_tick_clock.h" |
14 #include "media/base/fake_single_thread_task_runner.h" | 14 #include "media/base/fake_single_thread_task_runner.h" |
15 #include "media/base/video_frame.h" | 15 #include "media/base/video_frame.h" |
16 #include "media/cast/cast_environment.h" | 16 #include "media/cast/cast_environment.h" |
17 #include "media/cast/constants.h" | 17 #include "media/cast/constants.h" |
18 #include "media/cast/logging/simple_event_subscriber.h" | 18 #include "media/cast/logging/simple_event_subscriber.h" |
19 #include "media/cast/net/cast_transport_config.h" | 19 #include "media/cast/net/cast_transport_config.h" |
20 #include "media/cast/net/cast_transport_impl.h" | 20 #include "media/cast/net/cast_transport_impl.h" |
21 #include "media/cast/net/pacing/paced_sender.h" | 21 #include "media/cast/net/pacing/paced_sender.h" |
22 #include "media/cast/sender/fake_video_encode_accelerator_factory.h" | 22 #include "media/cast/sender/fake_video_encode_accelerator_factory.h" |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
128 }; | 128 }; |
129 | 129 |
130 class TransportClient : public CastTransport::Client { | 130 class TransportClient : public CastTransport::Client { |
131 public: | 131 public: |
132 TransportClient() {} | 132 TransportClient() {} |
133 | 133 |
134 void OnStatusChanged(CastTransportStatus status) final { | 134 void OnStatusChanged(CastTransportStatus status) final { |
135 EXPECT_EQ(TRANSPORT_VIDEO_INITIALIZED, status); | 135 EXPECT_EQ(TRANSPORT_VIDEO_INITIALIZED, status); |
136 }; | 136 }; |
137 void OnLoggingEventsReceived( | 137 void OnLoggingEventsReceived( |
138 scoped_ptr<std::vector<FrameEvent>> frame_events, | 138 std::unique_ptr<std::vector<FrameEvent>> frame_events, |
139 scoped_ptr<std::vector<PacketEvent>> packet_events) final{}; | 139 std::unique_ptr<std::vector<PacketEvent>> packet_events) final{}; |
140 void ProcessRtpPacket(scoped_ptr<Packet> packet) final{}; | 140 void ProcessRtpPacket(std::unique_ptr<Packet> packet) final{}; |
141 | 141 |
142 DISALLOW_COPY_AND_ASSIGN(TransportClient); | 142 DISALLOW_COPY_AND_ASSIGN(TransportClient); |
143 }; | 143 }; |
144 | 144 |
145 } // namespace | 145 } // namespace |
146 | 146 |
147 class VideoSenderTest : public ::testing::Test { | 147 class VideoSenderTest : public ::testing::Test { |
148 protected: | 148 protected: |
149 VideoSenderTest() | 149 VideoSenderTest() |
150 : testing_clock_(new base::SimpleTestTickClock()), | 150 : testing_clock_(new base::SimpleTestTickClock()), |
151 task_runner_(new FakeSingleThreadTaskRunner(testing_clock_)), | 151 task_runner_(new FakeSingleThreadTaskRunner(testing_clock_)), |
152 cast_environment_( | 152 cast_environment_(new CastEnvironment( |
153 new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_), | 153 std::unique_ptr<base::TickClock>(testing_clock_), |
154 task_runner_, | 154 task_runner_, |
155 task_runner_, | 155 task_runner_, |
156 task_runner_)), | 156 task_runner_)), |
157 operational_status_(STATUS_UNINITIALIZED), | 157 operational_status_(STATUS_UNINITIALIZED), |
158 vea_factory_(task_runner_) { | 158 vea_factory_(task_runner_) { |
159 testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); | 159 testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); |
160 vea_factory_.SetAutoRespond(true); | 160 vea_factory_.SetAutoRespond(true); |
161 last_pixel_value_ = kPixelValue; | 161 last_pixel_value_ = kPixelValue; |
162 transport_ = new TestPacketSender(); | 162 transport_ = new TestPacketSender(); |
163 transport_sender_.reset( | 163 transport_sender_.reset( |
164 new CastTransportImpl(testing_clock_, base::TimeDelta(), | 164 new CastTransportImpl(testing_clock_, base::TimeDelta(), |
165 make_scoped_ptr(new TransportClient()), | 165 base::WrapUnique(new TransportClient()), |
166 make_scoped_ptr(transport_), task_runner_)); | 166 base::WrapUnique(transport_), task_runner_)); |
167 } | 167 } |
168 | 168 |
169 ~VideoSenderTest() override {} | 169 ~VideoSenderTest() override {} |
170 | 170 |
171 void TearDown() final { | 171 void TearDown() final { |
172 video_sender_.reset(); | 172 video_sender_.reset(); |
173 task_runner_->RunTasks(); | 173 task_runner_->RunTasks(); |
174 } | 174 } |
175 | 175 |
176 // If |external| is true then external video encoder (VEA) is used. | 176 // If |external| is true then external video encoder (VEA) is used. |
177 // |expect_init_success| is true if initialization is expected to succeed. | 177 // |expect_init_success| is true if initialization is expected to succeed. |
178 void InitEncoder(bool external, bool expect_init_success) { | 178 void InitEncoder(bool external, bool expect_init_success) { |
179 VideoSenderConfig video_config = GetDefaultVideoSenderConfig(); | 179 VideoSenderConfig video_config = GetDefaultVideoSenderConfig(); |
180 video_config.use_external_encoder = external; | 180 video_config.use_external_encoder = external; |
181 | 181 |
182 ASSERT_EQ(operational_status_, STATUS_UNINITIALIZED); | 182 ASSERT_EQ(operational_status_, STATUS_UNINITIALIZED); |
183 | 183 |
184 if (external) { | 184 if (external) { |
185 vea_factory_.SetInitializationWillSucceed(expect_init_success); | 185 vea_factory_.SetInitializationWillSucceed(expect_init_success); |
186 video_sender_.reset(new PeerVideoSender( | 186 video_sender_.reset(new PeerVideoSender( |
187 cast_environment_, | 187 cast_environment_, video_config, |
188 video_config, | |
189 base::Bind(&SaveOperationalStatus, &operational_status_), | 188 base::Bind(&SaveOperationalStatus, &operational_status_), |
190 base::Bind( | 189 base::Bind( |
191 &FakeVideoEncodeAcceleratorFactory::CreateVideoEncodeAccelerator, | 190 &FakeVideoEncodeAcceleratorFactory::CreateVideoEncodeAccelerator, |
192 base::Unretained(&vea_factory_)), | 191 base::Unretained(&vea_factory_)), |
193 base::Bind(&FakeVideoEncodeAcceleratorFactory::CreateSharedMemory, | 192 base::Bind(&FakeVideoEncodeAcceleratorFactory::CreateSharedMemory, |
194 base::Unretained(&vea_factory_)), | 193 base::Unretained(&vea_factory_)), |
195 transport_sender_.get())); | 194 transport_sender_.get())); |
196 } else { | 195 } else { |
197 video_sender_.reset(new PeerVideoSender( | 196 video_sender_.reset(new PeerVideoSender( |
198 cast_environment_, | 197 cast_environment_, video_config, |
199 video_config, | |
200 base::Bind(&SaveOperationalStatus, &operational_status_), | 198 base::Bind(&SaveOperationalStatus, &operational_status_), |
201 CreateDefaultVideoEncodeAcceleratorCallback(), | 199 CreateDefaultVideoEncodeAcceleratorCallback(), |
202 CreateDefaultVideoEncodeMemoryCallback(), | 200 CreateDefaultVideoEncodeMemoryCallback(), transport_sender_.get())); |
203 transport_sender_.get())); | |
204 } | 201 } |
205 task_runner_->RunTasks(); | 202 task_runner_->RunTasks(); |
206 } | 203 } |
207 | 204 |
208 scoped_refptr<media::VideoFrame> GetNewVideoFrame() { | 205 scoped_refptr<media::VideoFrame> GetNewVideoFrame() { |
209 if (first_frame_timestamp_.is_null()) | 206 if (first_frame_timestamp_.is_null()) |
210 first_frame_timestamp_ = testing_clock_->NowTicks(); | 207 first_frame_timestamp_ = testing_clock_->NowTicks(); |
211 gfx::Size size(kWidth, kHeight); | 208 gfx::Size size(kWidth, kHeight); |
212 scoped_refptr<media::VideoFrame> video_frame = | 209 scoped_refptr<media::VideoFrame> video_frame = |
213 media::VideoFrame::CreateFrame( | 210 media::VideoFrame::CreateFrame( |
(...skipping 18 matching lines...) Expand all Loading... |
232 void RunTasks(int during_ms) { | 229 void RunTasks(int during_ms) { |
233 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(during_ms)); | 230 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(during_ms)); |
234 } | 231 } |
235 | 232 |
236 base::SimpleTestTickClock* const testing_clock_; // Owned by CastEnvironment. | 233 base::SimpleTestTickClock* const testing_clock_; // Owned by CastEnvironment. |
237 const scoped_refptr<FakeSingleThreadTaskRunner> task_runner_; | 234 const scoped_refptr<FakeSingleThreadTaskRunner> task_runner_; |
238 const scoped_refptr<CastEnvironment> cast_environment_; | 235 const scoped_refptr<CastEnvironment> cast_environment_; |
239 OperationalStatus operational_status_; | 236 OperationalStatus operational_status_; |
240 FakeVideoEncodeAcceleratorFactory vea_factory_; | 237 FakeVideoEncodeAcceleratorFactory vea_factory_; |
241 TestPacketSender* transport_; // Owned by CastTransport. | 238 TestPacketSender* transport_; // Owned by CastTransport. |
242 scoped_ptr<CastTransportImpl> transport_sender_; | 239 std::unique_ptr<CastTransportImpl> transport_sender_; |
243 scoped_ptr<PeerVideoSender> video_sender_; | 240 std::unique_ptr<PeerVideoSender> video_sender_; |
244 int last_pixel_value_; | 241 int last_pixel_value_; |
245 base::TimeTicks first_frame_timestamp_; | 242 base::TimeTicks first_frame_timestamp_; |
246 | 243 |
247 private: | 244 private: |
248 DISALLOW_COPY_AND_ASSIGN(VideoSenderTest); | 245 DISALLOW_COPY_AND_ASSIGN(VideoSenderTest); |
249 }; | 246 }; |
250 | 247 |
251 TEST_F(VideoSenderTest, BuiltInEncoder) { | 248 TEST_F(VideoSenderTest, BuiltInEncoder) { |
252 InitEncoder(false, true); | 249 InitEncoder(false, true); |
253 ASSERT_EQ(STATUS_INITIALIZED, operational_status_); | 250 ASSERT_EQ(STATUS_INITIALIZED, operational_status_); |
(...skipping 380 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
634 video_frame, | 631 video_frame, |
635 testing_clock_->NowTicks() + base::TimeDelta::FromMilliseconds(1000)); | 632 testing_clock_->NowTicks() + base::TimeDelta::FromMilliseconds(1000)); |
636 RunTasks(33); | 633 RunTasks(33); |
637 transport_->SetPause(false); | 634 transport_->SetPause(false); |
638 RunTasks(33); | 635 RunTasks(33); |
639 EXPECT_EQ(2, transport_->number_of_rtp_packets()); | 636 EXPECT_EQ(2, transport_->number_of_rtp_packets()); |
640 } | 637 } |
641 | 638 |
642 } // namespace cast | 639 } // namespace cast |
643 } // namespace media | 640 } // namespace media |
OLD | NEW |