media/cast/net/cast_transport_sender_impl_unittest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include <gtest/gtest.h>
   6 #include <stdint.h>
   7
   8 #include "base/bind.h"
   9 #include "base/bind_helpers.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/test/simple_test_tick_clock.h"
  12 #include "base/values.h"
  13 #include "media/cast/cast_config.h"
  14 #include "media/cast/net/cast_transport_config.h"
  15 #include "media/cast/net/cast_transport_sender_impl.h"
  16 #include "media/cast/net/rtcp/rtcp.h"
  17 #include "media/cast/test/fake_single_thread_task_runner.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 namespace media {
  21 namespace cast {
  22
  23 namespace {
  24 const int64 kStartMillisecond = INT64_C(12345678900000);
  25 const uint32 kVideoSsrc = 1;
  26 const uint32 kAudioSsrc = 2;
  27 }  // namespace
  28
  29 class FakePacketSender : public PacketSender {
  30  public:
  31   FakePacketSender()
  32       : paused_(false), packets_sent_(0), bytes_sent_(0) {}
  33
  34   bool SendPacket(PacketRef packet, const base::Closure& cb) final {
  35     if (paused_) {
  36       stored_packet_ = packet;
  37       callback_ = cb;
  38       return false;
  39     }
  40     ++packets_sent_;
  41     bytes_sent_ += packet->data.size();
  42     return true;
  43   }
  44
  45   int64 GetBytesSent() final { return bytes_sent_; }
  46
  47   void SetPaused(bool paused) {
  48     paused_ = paused;
  49     if (!paused && stored_packet_.get()) {
  50       SendPacket(stored_packet_, callback_);
  51       callback_.Run();
  52     }
  53   }
  54
  55   int packets_sent() const { return packets_sent_; }
  56
  57  private:
  58   bool paused_;
  59   base::Closure callback_;
  60   PacketRef stored_packet_;
  61   int packets_sent_;
  62   int64 bytes_sent_;
  63
  64   DISALLOW_COPY_AND_ASSIGN(FakePacketSender);
  65 };
  66
  67 class CastTransportSenderImplTest : public ::testing::Test {
  68  protected:
  69   CastTransportSenderImplTest()
  70       : num_times_callback_called_(0) {
  71     testing_clock_.Advance(
  72         base::TimeDelta::FromMilliseconds(kStartMillisecond));
  73     task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_);
  74   }
  75
  76   ~CastTransportSenderImplTest() override {}
  77
  78   void InitWithoutLogging() {
  79     transport_sender_.reset(
  80         new CastTransportSenderImpl(NULL,
  81                                     &testing_clock_,
  82                                     net::IPEndPoint(),
  83                                     net::IPEndPoint(),
  84                                     make_scoped_ptr(new base::DictionaryValue),
  85                                     base::Bind(&UpdateCastTransportStatus),
  86                                     BulkRawEventsCallback(),
  87                                     base::TimeDelta(),
  88                                     task_runner_,
  89                                     PacketReceiverCallback(),
  90                                     &transport_));
  91     task_runner_->RunTasks();
  92   }
  93
  94   void InitWithOptions() {
  95     scoped_ptr<base::DictionaryValue> options(
  96         new base::DictionaryValue);
  97     options->SetBoolean("DHCP", true);
  98     options->SetBoolean("disable_wifi_scan", true);
  99     options->SetBoolean("media_streaming_mode", true);
 100     options->SetInteger("pacer_target_burst_size", 20);
 101     options->SetInteger("pacer_max_burst_size", 100);
 102     transport_sender_.reset(
 103         new CastTransportSenderImpl(NULL,
 104                                     &testing_clock_,
 105                                     net::IPEndPoint(),
 106                                     net::IPEndPoint(),
 107                                     options.Pass(),
 108                                     base::Bind(&UpdateCastTransportStatus),
 109                                     BulkRawEventsCallback(),
 110                                     base::TimeDelta(),
 111                                     task_runner_,
 112                                     PacketReceiverCallback(),
 113                                     &transport_));
 114     task_runner_->RunTasks();
 115   }
 116
 117   void InitWithLogging() {
 118     transport_sender_.reset(new CastTransportSenderImpl(
 119         NULL,
 120         &testing_clock_,
 121         net::IPEndPoint(),
 122         net::IPEndPoint(),
 123         make_scoped_ptr(new base::DictionaryValue),
 124         base::Bind(&UpdateCastTransportStatus),
 125         base::Bind(&CastTransportSenderImplTest::LogRawEvents,
 126                    base::Unretained(this)),
 127         base::TimeDelta::FromMilliseconds(10),
 128         task_runner_,
 129         PacketReceiverCallback(),
 130         &transport_));
 131     task_runner_->RunTasks();
 132   }
 133
 134   void InitializeVideo() {
 135     CastTransportRtpConfig rtp_config;
 136     rtp_config.ssrc = kVideoSsrc;
 137     rtp_config.feedback_ssrc = 2;
 138     rtp_config.rtp_payload_type = 3;
 139     transport_sender_->InitializeVideo(rtp_config,
 140                                        RtcpCastMessageCallback(),
 141                                        RtcpRttCallback());
 142   }
 143
 144   void InitializeAudio() {
 145     CastTransportRtpConfig rtp_config;
 146     rtp_config.ssrc = kAudioSsrc;
 147     rtp_config.feedback_ssrc = 3;
 148     rtp_config.rtp_payload_type = 4;
 149     transport_sender_->InitializeAudio(rtp_config,
 150                                        RtcpCastMessageCallback(),
 151                                        RtcpRttCallback());
 152   }
 153
 154   void LogRawEvents(const std::vector<PacketEvent>& packet_events,
 155                     const std::vector<FrameEvent>& frame_events) {
 156     num_times_callback_called_++;
 157   }
 158
 159   static void UpdateCastTransportStatus(CastTransportStatus status) {
 160   }
 161
 162   base::SimpleTestTickClock testing_clock_;
 163   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
 164   scoped_ptr<CastTransportSenderImpl> transport_sender_;
 165   FakePacketSender transport_;
 166   int num_times_callback_called_;
 167 };
 168
 169 TEST_F(CastTransportSenderImplTest, InitWithoutLogging) {
 170   InitWithoutLogging();
 171   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
 172   EXPECT_EQ(0, num_times_callback_called_);
 173 }
 174
 175 TEST_F(CastTransportSenderImplTest, InitWithLogging) {
 176   InitWithLogging();
 177   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
 178   EXPECT_EQ(5, num_times_callback_called_);
 179 }
 180
 181 TEST_F(CastTransportSenderImplTest, InitWithOptions) {
 182   InitWithOptions();
 183   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
 184   EXPECT_EQ(0, num_times_callback_called_);
 185 }
 186
 187 TEST_F(CastTransportSenderImplTest, NacksCancelRetransmits) {
 188   InitWithoutLogging();
 189   InitializeVideo();
 190   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
 191
 192   // A fake frame that will be decomposed into 4 packets.
 193   EncodedFrame fake_frame;
 194   fake_frame.frame_id = 1;
 195   fake_frame.rtp_timestamp = 1;
 196   fake_frame.dependency = EncodedFrame::KEY;
 197   fake_frame.data.resize(5000, ' ');
 198
 199   transport_sender_->InsertFrame(kVideoSsrc, fake_frame);
 200   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
 201   EXPECT_EQ(4, transport_.packets_sent());
 202
 203   // Resend packet 0.
 204   MissingFramesAndPacketsMap missing_packets;
 205   missing_packets[1].insert(0);
 206   missing_packets[1].insert(1);
 207   missing_packets[1].insert(2);
 208
 209   transport_.SetPaused(true);
 210   DedupInfo dedup_info;
 211   dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10);
 212   transport_sender_->ResendPackets(
 213       kVideoSsrc, missing_packets, true, dedup_info);
 214
 215   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
 216
 217   RtcpCastMessage cast_message;
 218   cast_message.media_ssrc = kVideoSsrc;
 219   cast_message.ack_frame_id = 1;
 220   cast_message.missing_frames_and_packets[1].insert(3);
 221   transport_sender_->OnReceivedCastMessage(kVideoSsrc,
 222                                            RtcpCastMessageCallback(),
 223                                            cast_message);
 224   transport_.SetPaused(false);
 225   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
 226
 227   // Resend one packet in the socket when unpaused.
 228   // Resend one more packet from NACK.
 229   EXPECT_EQ(6, transport_.packets_sent());
 230 }
 231
 232 TEST_F(CastTransportSenderImplTest, CancelRetransmits) {
 233   InitWithoutLogging();
 234   InitializeVideo();
 235   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
 236
 237   // A fake frame that will be decomposed into 4 packets.
 238   EncodedFrame fake_frame;
 239   fake_frame.frame_id = 1;
 240   fake_frame.rtp_timestamp = 1;
 241   fake_frame.dependency = EncodedFrame::KEY;
 242   fake_frame.data.resize(5000, ' ');
 243
 244   transport_sender_->InsertFrame(kVideoSsrc, fake_frame);
 245   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
 246   EXPECT_EQ(4, transport_.packets_sent());
 247
 248   // Resend all packets for frame 1.
 249   MissingFramesAndPacketsMap missing_packets;
 250   missing_packets[1].insert(kRtcpCastAllPacketsLost);
 251
 252   transport_.SetPaused(true);
 253   DedupInfo dedup_info;
 254   dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10);
 255   transport_sender_->ResendPackets(
 256       kVideoSsrc, missing_packets, true, dedup_info);
 257
 258   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
 259   std::vector<uint32> cancel_sending_frames;
 260   cancel_sending_frames.push_back(1);
 261   transport_sender_->CancelSendingFrames(kVideoSsrc,
 262                                          cancel_sending_frames);
 263   transport_.SetPaused(false);
 264   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
 265
 266   // Resend one packet in the socket when unpaused.
 267   EXPECT_EQ(5, transport_.packets_sent());
 268 }
 269
 270 TEST_F(CastTransportSenderImplTest, Kickstart) {
 271   InitWithoutLogging();
 272   InitializeVideo();
 273   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
 274
 275   // A fake frame that will be decomposed into 4 packets.
 276   EncodedFrame fake_frame;
 277   fake_frame.frame_id = 1;
 278   fake_frame.rtp_timestamp = 1;
 279   fake_frame.dependency = EncodedFrame::KEY;
 280   fake_frame.data.resize(5000, ' ');
 281
 282   transport_.SetPaused(true);
 283   transport_sender_->InsertFrame(kVideoSsrc, fake_frame);
 284   transport_sender_->ResendFrameForKickstart(kVideoSsrc, 1);
 285   transport_.SetPaused(false);
 286   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
 287   EXPECT_EQ(4, transport_.packets_sent());
 288
 289   // Resend 2 packets for frame 1.
 290   MissingFramesAndPacketsMap missing_packets;
 291   missing_packets[1].insert(0);
 292   missing_packets[1].insert(1);
 293
 294   transport_.SetPaused(true);
 295   DedupInfo dedup_info;
 296   dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10);
 297   transport_sender_->ResendPackets(
 298       kVideoSsrc, missing_packets, true, dedup_info);
 299   transport_sender_->ResendFrameForKickstart(kVideoSsrc, 1);
 300   transport_.SetPaused(false);
 301   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
 302
 303   // Resend one packet in the socket when unpaused.
 304   // Two more retransmission packets sent.
 305   EXPECT_EQ(7, transport_.packets_sent());
 306 }
 307
 308 TEST_F(CastTransportSenderImplTest, DedupRetransmissionWithAudio) {
 309   InitWithoutLogging();
 310   InitializeAudio();
 311   InitializeVideo();
 312   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
 313
 314   // Send two audio frames.
 315   EncodedFrame fake_audio;
 316   fake_audio.frame_id = 1;
 317   fake_audio.reference_time = testing_clock_.NowTicks();
 318   fake_audio.dependency = EncodedFrame::KEY;
 319   fake_audio.data.resize(100, ' ');
 320   transport_sender_->InsertFrame(kAudioSsrc, fake_audio);
 321   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
 322   fake_audio.frame_id = 2;
 323   fake_audio.reference_time = testing_clock_.NowTicks();
 324   transport_sender_->InsertFrame(kAudioSsrc, fake_audio);
 325   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
 326   EXPECT_EQ(2, transport_.packets_sent());
 327
 328   // Ack the first audio frame.
 329   RtcpCastMessage cast_message;
 330   cast_message.media_ssrc = kAudioSsrc;
 331   cast_message.ack_frame_id = 1;
 332   transport_sender_->OnReceivedCastMessage(kAudioSsrc,
 333                                            RtcpCastMessageCallback(),
 334                                            cast_message);
 335   task_runner_->RunTasks();
 336   EXPECT_EQ(2, transport_.packets_sent());
 337
 338   // Send a fake video frame that will be decomposed into 4 packets.
 339   EncodedFrame fake_video;
 340   fake_video.frame_id = 1;
 341   fake_video.dependency = EncodedFrame::KEY;
 342   fake_video.data.resize(5000, ' ');
 343   transport_sender_->InsertFrame(kVideoSsrc, fake_video);
 344   task_runner_->RunTasks();
 345   EXPECT_EQ(6, transport_.packets_sent());
 346
 347   // Retransmission is reject because audio is not acked yet.
 348   cast_message.media_ssrc = kVideoSsrc;
 349   cast_message.ack_frame_id = 0;
 350   cast_message.missing_frames_and_packets[1].insert(3);
 351   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
 352   transport_sender_->OnReceivedCastMessage(kVideoSsrc,
 353                                            RtcpCastMessageCallback(),
 354                                            cast_message);
 355   task_runner_->RunTasks();
 356   EXPECT_EQ(6, transport_.packets_sent());
 357
 358   // Ack the second audio frame.
 359   cast_message.media_ssrc = kAudioSsrc;
 360   cast_message.ack_frame_id = 2;
 361   cast_message.missing_frames_and_packets.clear();
 362   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
 363   transport_sender_->OnReceivedCastMessage(kAudioSsrc,
 364                                            RtcpCastMessageCallback(),
 365                                            cast_message);
 366   task_runner_->RunTasks();
 367   EXPECT_EQ(6, transport_.packets_sent());
 368
 369   // Retransmission of video packet now accepted.
 370   cast_message.media_ssrc = kVideoSsrc;
 371   cast_message.ack_frame_id = 1;
 372   cast_message.missing_frames_and_packets[1].insert(3);
 373   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
 374   transport_sender_->OnReceivedCastMessage(kVideoSsrc,
 375                                            RtcpCastMessageCallback(),
 376                                            cast_message);
 377   task_runner_->RunTasks();
 378   EXPECT_EQ(7, transport_.packets_sent());
 379 }
 380
 381 }  // namespace cast
 382 }  // namespace media