media/cast/net/cast_transport_sender_impl_unittest.cc - platform/external/chromium_org - Git at Google

 // Copyright 2014 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 <gtest/gtest.h>
 #include <stdint.h>

 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/values.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/cast_transport_sender_impl.h"
 #include "media/cast/net/rtcp/rtcp.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace media {
 namespace cast {

 namespace {
 const int64 kStartMillisecond = INT64_C(12345678900000);
 const uint32 kVideoSsrc = 1;
 const uint32 kAudioSsrc = 2;
 }  // namespace

 class FakePacketSender : public PacketSender {
  public:
   FakePacketSender()
       : paused_(false), packets_sent_(0), bytes_sent_(0) {}

   bool SendPacket(PacketRef packet, const base::Closure& cb) override {
     if (paused_) {
       stored_packet_ = packet;
       callback_ = cb;
       return false;
     }
     ++packets_sent_;
     bytes_sent_ += packet->data.size();
     return true;
   }

   int64 GetBytesSent() override { return bytes_sent_; }

   void SetPaused(bool paused) {
     paused_ = paused;
     if (!paused && stored_packet_.get()) {
       SendPacket(stored_packet_, callback_);
       callback_.Run();
     }
   }

   int packets_sent() const { return packets_sent_; }

  private:
   bool paused_;
   base::Closure callback_;
   PacketRef stored_packet_;
   int packets_sent_;
   int64 bytes_sent_;

   DISALLOW_COPY_AND_ASSIGN(FakePacketSender);
 };

 class CastTransportSenderImplTest : public ::testing::Test {
  protected:
   CastTransportSenderImplTest()
       : num_times_callback_called_(0) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_);
   }

   ~CastTransportSenderImplTest() override {}

   void InitWithoutLogging() {
     transport_sender_.reset(
         new CastTransportSenderImpl(NULL,
                                     &testing_clock_,
                                     net::IPEndPoint(),
                                     make_scoped_ptr(new base::DictionaryValue),
                                     base::Bind(&UpdateCastTransportStatus),
                                     BulkRawEventsCallback(),
                                     base::TimeDelta(),
                                     task_runner_,
                                     &transport_));
     task_runner_->RunTasks();
   }

   void InitWithOptions() {
     scoped_ptr<base::DictionaryValue> options(
         new base::DictionaryValue);
     options->SetBoolean("DHCP", true);
     options->SetBoolean("disable_wifi_scan", true);
     options->SetBoolean("media_streaming_mode", true);
     options->SetInteger("pacer_target_burst_size", 20);
     options->SetInteger("pacer_max_burst_size", 100);
     transport_sender_.reset(
         new CastTransportSenderImpl(NULL,
                                     &testing_clock_,
                                     net::IPEndPoint(),
                                     options.Pass(),
                                     base::Bind(&UpdateCastTransportStatus),
                                     BulkRawEventsCallback(),
                                     base::TimeDelta(),
                                     task_runner_,
                                     &transport_));
     task_runner_->RunTasks();
   }

   void InitWithLogging() {
     transport_sender_.reset(new CastTransportSenderImpl(
         NULL,
         &testing_clock_,
         net::IPEndPoint(),
         make_scoped_ptr(new base::DictionaryValue),
         base::Bind(&UpdateCastTransportStatus),
         base::Bind(&CastTransportSenderImplTest::LogRawEvents,
                    base::Unretained(this)),
         base::TimeDelta::FromMilliseconds(10),
         task_runner_,
         &transport_));
     task_runner_->RunTasks();
   }

   void InitializeVideo() {
     CastTransportRtpConfig rtp_config;
     rtp_config.ssrc = kVideoSsrc;
     rtp_config.feedback_ssrc = 2;
     rtp_config.rtp_payload_type = 3;
     transport_sender_->InitializeVideo(rtp_config,
                                        RtcpCastMessageCallback(),
                                        RtcpRttCallback());
   }

   void InitializeAudio() {
     CastTransportRtpConfig rtp_config;
     rtp_config.ssrc = kAudioSsrc;
     rtp_config.feedback_ssrc = 3;
     rtp_config.rtp_payload_type = 4;
     transport_sender_->InitializeAudio(rtp_config,
                                        RtcpCastMessageCallback(),
                                        RtcpRttCallback());
   }

   void LogRawEvents(const std::vector<PacketEvent>& packet_events,
                     const std::vector<FrameEvent>& frame_events) {
     num_times_callback_called_++;
   }

   static void UpdateCastTransportStatus(CastTransportStatus status) {
   }

   base::SimpleTestTickClock testing_clock_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_ptr<CastTransportSenderImpl> transport_sender_;
   FakePacketSender transport_;
   int num_times_callback_called_;
 };

 TEST_F(CastTransportSenderImplTest, InitWithoutLogging) {
   InitWithoutLogging();
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
   EXPECT_EQ(0, num_times_callback_called_);
 }

 TEST_F(CastTransportSenderImplTest, InitWithLogging) {
   InitWithLogging();
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
   EXPECT_EQ(5, num_times_callback_called_);
 }

 TEST_F(CastTransportSenderImplTest, InitWithOptions) {
   InitWithOptions();
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
   EXPECT_EQ(0, num_times_callback_called_);
 }

 TEST_F(CastTransportSenderImplTest, NacksCancelRetransmits) {
   InitWithoutLogging();
   InitializeVideo();
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));

   // A fake frame that will be decomposed into 4 packets.
   EncodedFrame fake_frame;
   fake_frame.frame_id = 1;
   fake_frame.rtp_timestamp = 1;
   fake_frame.dependency = EncodedFrame::KEY;
   fake_frame.data.resize(5000, ' ');

   transport_sender_->InsertFrame(kVideoSsrc, fake_frame);
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
   EXPECT_EQ(4, transport_.packets_sent());

   // Resend packet 0.
   MissingFramesAndPacketsMap missing_packets;
   missing_packets[1].insert(0);
   missing_packets[1].insert(1);
   missing_packets[1].insert(2);

   transport_.SetPaused(true);
   DedupInfo dedup_info;
   dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10);
   transport_sender_->ResendPackets(
       kVideoSsrc, missing_packets, true, dedup_info);

   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));

   RtcpCastMessage cast_message;
   cast_message.media_ssrc = kVideoSsrc;
   cast_message.ack_frame_id = 1;
   cast_message.missing_frames_and_packets[1].insert(3);
   transport_sender_->OnReceivedCastMessage(kVideoSsrc,
                                            RtcpCastMessageCallback(),
                                            cast_message);
   transport_.SetPaused(false);
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));

   // Resend one packet in the socket when unpaused.
   // Resend one more packet from NACK.
   EXPECT_EQ(6, transport_.packets_sent());
 }

 TEST_F(CastTransportSenderImplTest, CancelRetransmits) {
   InitWithoutLogging();
   InitializeVideo();
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));

   // A fake frame that will be decomposed into 4 packets.
   EncodedFrame fake_frame;
   fake_frame.frame_id = 1;
   fake_frame.rtp_timestamp = 1;
   fake_frame.dependency = EncodedFrame::KEY;
   fake_frame.data.resize(5000, ' ');

   transport_sender_->InsertFrame(kVideoSsrc, fake_frame);
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
   EXPECT_EQ(4, transport_.packets_sent());

   // Resend all packets for frame 1.
   MissingFramesAndPacketsMap missing_packets;
   missing_packets[1].insert(kRtcpCastAllPacketsLost);

   transport_.SetPaused(true);
   DedupInfo dedup_info;
   dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10);
   transport_sender_->ResendPackets(
       kVideoSsrc, missing_packets, true, dedup_info);

   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
   std::vector<uint32> cancel_sending_frames;
   cancel_sending_frames.push_back(1);
   transport_sender_->CancelSendingFrames(kVideoSsrc,
                                          cancel_sending_frames);
   transport_.SetPaused(false);
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));

   // Resend one packet in the socket when unpaused.
   EXPECT_EQ(5, transport_.packets_sent());
 }

 TEST_F(CastTransportSenderImplTest, Kickstart) {
   InitWithoutLogging();
   InitializeVideo();
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));

   // A fake frame that will be decomposed into 4 packets.
   EncodedFrame fake_frame;
   fake_frame.frame_id = 1;
   fake_frame.rtp_timestamp = 1;
   fake_frame.dependency = EncodedFrame::KEY;
   fake_frame.data.resize(5000, ' ');

   transport_.SetPaused(true);
   transport_sender_->InsertFrame(kVideoSsrc, fake_frame);
   transport_sender_->ResendFrameForKickstart(kVideoSsrc, 1);
   transport_.SetPaused(false);
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
   EXPECT_EQ(4, transport_.packets_sent());

   // Resend 2 packets for frame 1.
   MissingFramesAndPacketsMap missing_packets;
   missing_packets[1].insert(0);
   missing_packets[1].insert(1);

   transport_.SetPaused(true);
   DedupInfo dedup_info;
   dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10);
   transport_sender_->ResendPackets(
       kVideoSsrc, missing_packets, true, dedup_info);
   transport_sender_->ResendFrameForKickstart(kVideoSsrc, 1);
   transport_.SetPaused(false);
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));

   // Resend one packet in the socket when unpaused.
   // Two more retransmission packets sent.
   EXPECT_EQ(7, transport_.packets_sent());
 }

 TEST_F(CastTransportSenderImplTest, DedupRetransmissionWithAudio) {
   InitWithoutLogging();
   InitializeAudio();
   InitializeVideo();
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));

   // Send two audio frames.
   EncodedFrame fake_audio;
   fake_audio.frame_id = 1;
   fake_audio.reference_time = testing_clock_.NowTicks();
   fake_audio.dependency = EncodedFrame::KEY;
   fake_audio.data.resize(100, ' ');
   transport_sender_->InsertFrame(kAudioSsrc, fake_audio);
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
   fake_audio.frame_id = 2;
   fake_audio.reference_time = testing_clock_.NowTicks();
   transport_sender_->InsertFrame(kAudioSsrc, fake_audio);
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
   EXPECT_EQ(2, transport_.packets_sent());

   // Ack the first audio frame.
   RtcpCastMessage cast_message;
   cast_message.media_ssrc = kAudioSsrc;
   cast_message.ack_frame_id = 1;
   transport_sender_->OnReceivedCastMessage(kAudioSsrc,
                                            RtcpCastMessageCallback(),
                                            cast_message);
   task_runner_->RunTasks();
   EXPECT_EQ(2, transport_.packets_sent());

   // Send a fake video frame that will be decomposed into 4 packets.
   EncodedFrame fake_video;
   fake_video.frame_id = 1;
   fake_video.dependency = EncodedFrame::KEY;
   fake_video.data.resize(5000, ' ');
   transport_sender_->InsertFrame(kVideoSsrc, fake_video);
   task_runner_->RunTasks();
   EXPECT_EQ(6, transport_.packets_sent());

   // Retransmission is reject because audio is not acked yet.
   cast_message.media_ssrc = kVideoSsrc;
   cast_message.ack_frame_id = 0;
   cast_message.missing_frames_and_packets[1].insert(3);
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
   transport_sender_->OnReceivedCastMessage(kVideoSsrc,
                                            RtcpCastMessageCallback(),
                                            cast_message);
   task_runner_->RunTasks();
   EXPECT_EQ(6, transport_.packets_sent());

   // Ack the second audio frame.
   cast_message.media_ssrc = kAudioSsrc;
   cast_message.ack_frame_id = 2;
   cast_message.missing_frames_and_packets.clear();
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
   transport_sender_->OnReceivedCastMessage(kAudioSsrc,
                                            RtcpCastMessageCallback(),
                                            cast_message);
   task_runner_->RunTasks();
   EXPECT_EQ(6, transport_.packets_sent());

   // Retransmission of video packet now accepted.
   cast_message.media_ssrc = kVideoSsrc;
   cast_message.ack_frame_id = 1;
   cast_message.missing_frames_and_packets[1].insert(3);
   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
   transport_sender_->OnReceivedCastMessage(kVideoSsrc,
                                            RtcpCastMessageCallback(),
                                            cast_message);
   task_runner_->RunTasks();
   EXPECT_EQ(7, transport_.packets_sent());
 }

 }  // namespace cast
 }  // namespace media
	// Copyright 2014 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 <gtest/gtest.h>
	#include <stdint.h>

	#include "base/bind.h"
	#include "base/bind_helpers.h"
	#include "base/memory/scoped_ptr.h"
	#include "base/test/simple_test_tick_clock.h"
	#include "base/values.h"
	#include "media/cast/cast_config.h"
	#include "media/cast/net/cast_transport_config.h"
	#include "media/cast/net/cast_transport_sender_impl.h"
	#include "media/cast/net/rtcp/rtcp.h"
	#include "media/cast/test/fake_single_thread_task_runner.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace media {
	namespace cast {

	namespace {
	const int64 kStartMillisecond = INT64_C(12345678900000);
	const uint32 kVideoSsrc = 1;
	const uint32 kAudioSsrc = 2;
	} // namespace

	class FakePacketSender : public PacketSender {
	public:
	FakePacketSender()
	: paused_(false), packets_sent_(0), bytes_sent_(0) {}

	bool SendPacket(PacketRef packet, const base::Closure& cb) override {
	if (paused_) {
	stored_packet_ = packet;
	callback_ = cb;
	return false;
	}
	++packets_sent_;
	bytes_sent_ += packet->data.size();
	return true;
	}

	int64 GetBytesSent() override { return bytes_sent_; }

	void SetPaused(bool paused) {
	paused_ = paused;
	if (!paused && stored_packet_.get()) {
	SendPacket(stored_packet_, callback_);
	callback_.Run();
	}
	}

	int packets_sent() const { return packets_sent_; }

	private:
	bool paused_;
	base::Closure callback_;
	PacketRef stored_packet_;
	int packets_sent_;
	int64 bytes_sent_;

	DISALLOW_COPY_AND_ASSIGN(FakePacketSender);
	};

	class CastTransportSenderImplTest : public ::testing::Test {
	protected:
	CastTransportSenderImplTest()
	: num_times_callback_called_(0) {
	testing_clock_.Advance(
	base::TimeDelta::FromMilliseconds(kStartMillisecond));
	task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_);
	}

	~CastTransportSenderImplTest() override {}

	void InitWithoutLogging() {
	transport_sender_.reset(
	new CastTransportSenderImpl(NULL,
	&testing_clock_,
	net::IPEndPoint(),
	make_scoped_ptr(new base::DictionaryValue),
	base::Bind(&UpdateCastTransportStatus),
	BulkRawEventsCallback(),
	base::TimeDelta(),
	task_runner_,
	&transport_));
	task_runner_->RunTasks();
	}

	void InitWithOptions() {
	scoped_ptr<base::DictionaryValue> options(
	new base::DictionaryValue);
	options->SetBoolean("DHCP", true);
	options->SetBoolean("disable_wifi_scan", true);
	options->SetBoolean("media_streaming_mode", true);
	options->SetInteger("pacer_target_burst_size", 20);
	options->SetInteger("pacer_max_burst_size", 100);
	transport_sender_.reset(
	new CastTransportSenderImpl(NULL,
	&testing_clock_,
	net::IPEndPoint(),
	options.Pass(),
	base::Bind(&UpdateCastTransportStatus),
	BulkRawEventsCallback(),
	base::TimeDelta(),
	task_runner_,
	&transport_));
	task_runner_->RunTasks();
	}

	void InitWithLogging() {
	transport_sender_.reset(new CastTransportSenderImpl(
	NULL,
	&testing_clock_,
	net::IPEndPoint(),
	make_scoped_ptr(new base::DictionaryValue),
	base::Bind(&UpdateCastTransportStatus),
	base::Bind(&CastTransportSenderImplTest::LogRawEvents,
	base::Unretained(this)),
	base::TimeDelta::FromMilliseconds(10),
	task_runner_,
	&transport_));
	task_runner_->RunTasks();
	}

	void InitializeVideo() {
	CastTransportRtpConfig rtp_config;
	rtp_config.ssrc = kVideoSsrc;
	rtp_config.feedback_ssrc = 2;
	rtp_config.rtp_payload_type = 3;
	transport_sender_->InitializeVideo(rtp_config,
	RtcpCastMessageCallback(),
	RtcpRttCallback());
	}

	void InitializeAudio() {
	CastTransportRtpConfig rtp_config;
	rtp_config.ssrc = kAudioSsrc;
	rtp_config.feedback_ssrc = 3;
	rtp_config.rtp_payload_type = 4;
	transport_sender_->InitializeAudio(rtp_config,
	RtcpCastMessageCallback(),
	RtcpRttCallback());
	}

	void LogRawEvents(const std::vector<PacketEvent>& packet_events,
	const std::vector<FrameEvent>& frame_events) {
	num_times_callback_called_++;
	}

	static void UpdateCastTransportStatus(CastTransportStatus status) {
	}

	base::SimpleTestTickClock testing_clock_;
	scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
	scoped_ptr<CastTransportSenderImpl> transport_sender_;
	FakePacketSender transport_;
	int num_times_callback_called_;
	};

	TEST_F(CastTransportSenderImplTest, InitWithoutLogging) {
	InitWithoutLogging();
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
	EXPECT_EQ(0, num_times_callback_called_);
	}

	TEST_F(CastTransportSenderImplTest, InitWithLogging) {
	InitWithLogging();
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
	EXPECT_EQ(5, num_times_callback_called_);
	}

	TEST_F(CastTransportSenderImplTest, InitWithOptions) {
	InitWithOptions();
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));
	EXPECT_EQ(0, num_times_callback_called_);
	}

	TEST_F(CastTransportSenderImplTest, NacksCancelRetransmits) {
	InitWithoutLogging();
	InitializeVideo();
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));

	// A fake frame that will be decomposed into 4 packets.
	EncodedFrame fake_frame;
	fake_frame.frame_id = 1;
	fake_frame.rtp_timestamp = 1;
	fake_frame.dependency = EncodedFrame::KEY;
	fake_frame.data.resize(5000, ' ');

	transport_sender_->InsertFrame(kVideoSsrc, fake_frame);
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
	EXPECT_EQ(4, transport_.packets_sent());

	// Resend packet 0.
	MissingFramesAndPacketsMap missing_packets;
	missing_packets[1].insert(0);
	missing_packets[1].insert(1);
	missing_packets[1].insert(2);

	transport_.SetPaused(true);
	DedupInfo dedup_info;
	dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10);
	transport_sender_->ResendPackets(
	kVideoSsrc, missing_packets, true, dedup_info);

	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));

	RtcpCastMessage cast_message;
	cast_message.media_ssrc = kVideoSsrc;
	cast_message.ack_frame_id = 1;
	cast_message.missing_frames_and_packets[1].insert(3);
	transport_sender_->OnReceivedCastMessage(kVideoSsrc,
	RtcpCastMessageCallback(),
	cast_message);
	transport_.SetPaused(false);
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));

	// Resend one packet in the socket when unpaused.
	// Resend one more packet from NACK.
	EXPECT_EQ(6, transport_.packets_sent());
	}

	TEST_F(CastTransportSenderImplTest, CancelRetransmits) {
	InitWithoutLogging();
	InitializeVideo();
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));

	// A fake frame that will be decomposed into 4 packets.
	EncodedFrame fake_frame;
	fake_frame.frame_id = 1;
	fake_frame.rtp_timestamp = 1;
	fake_frame.dependency = EncodedFrame::KEY;
	fake_frame.data.resize(5000, ' ');

	transport_sender_->InsertFrame(kVideoSsrc, fake_frame);
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
	EXPECT_EQ(4, transport_.packets_sent());

	// Resend all packets for frame 1.
	MissingFramesAndPacketsMap missing_packets;
	missing_packets[1].insert(kRtcpCastAllPacketsLost);

	transport_.SetPaused(true);
	DedupInfo dedup_info;
	dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10);
	transport_sender_->ResendPackets(
	kVideoSsrc, missing_packets, true, dedup_info);

	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
	std::vector<uint32> cancel_sending_frames;
	cancel_sending_frames.push_back(1);
	transport_sender_->CancelSendingFrames(kVideoSsrc,
	cancel_sending_frames);
	transport_.SetPaused(false);
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));

	// Resend one packet in the socket when unpaused.
	EXPECT_EQ(5, transport_.packets_sent());
	}

	TEST_F(CastTransportSenderImplTest, Kickstart) {
	InitWithoutLogging();
	InitializeVideo();
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));

	// A fake frame that will be decomposed into 4 packets.
	EncodedFrame fake_frame;
	fake_frame.frame_id = 1;
	fake_frame.rtp_timestamp = 1;
	fake_frame.dependency = EncodedFrame::KEY;
	fake_frame.data.resize(5000, ' ');

	transport_.SetPaused(true);
	transport_sender_->InsertFrame(kVideoSsrc, fake_frame);
	transport_sender_->ResendFrameForKickstart(kVideoSsrc, 1);
	transport_.SetPaused(false);
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
	EXPECT_EQ(4, transport_.packets_sent());

	// Resend 2 packets for frame 1.
	MissingFramesAndPacketsMap missing_packets;
	missing_packets[1].insert(0);
	missing_packets[1].insert(1);

	transport_.SetPaused(true);
	DedupInfo dedup_info;
	dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10);
	transport_sender_->ResendPackets(
	kVideoSsrc, missing_packets, true, dedup_info);
	transport_sender_->ResendFrameForKickstart(kVideoSsrc, 1);
	transport_.SetPaused(false);
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));

	// Resend one packet in the socket when unpaused.
	// Two more retransmission packets sent.
	EXPECT_EQ(7, transport_.packets_sent());
	}

	TEST_F(CastTransportSenderImplTest, DedupRetransmissionWithAudio) {
	InitWithoutLogging();
	InitializeAudio();
	InitializeVideo();
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50));

	// Send two audio frames.
	EncodedFrame fake_audio;
	fake_audio.frame_id = 1;
	fake_audio.reference_time = testing_clock_.NowTicks();
	fake_audio.dependency = EncodedFrame::KEY;
	fake_audio.data.resize(100, ' ');
	transport_sender_->InsertFrame(kAudioSsrc, fake_audio);
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
	fake_audio.frame_id = 2;
	fake_audio.reference_time = testing_clock_.NowTicks();
	transport_sender_->InsertFrame(kAudioSsrc, fake_audio);
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
	EXPECT_EQ(2, transport_.packets_sent());

	// Ack the first audio frame.
	RtcpCastMessage cast_message;
	cast_message.media_ssrc = kAudioSsrc;
	cast_message.ack_frame_id = 1;
	transport_sender_->OnReceivedCastMessage(kAudioSsrc,
	RtcpCastMessageCallback(),
	cast_message);
	task_runner_->RunTasks();
	EXPECT_EQ(2, transport_.packets_sent());

	// Send a fake video frame that will be decomposed into 4 packets.
	EncodedFrame fake_video;
	fake_video.frame_id = 1;
	fake_video.dependency = EncodedFrame::KEY;
	fake_video.data.resize(5000, ' ');
	transport_sender_->InsertFrame(kVideoSsrc, fake_video);
	task_runner_->RunTasks();
	EXPECT_EQ(6, transport_.packets_sent());

	// Retransmission is reject because audio is not acked yet.
	cast_message.media_ssrc = kVideoSsrc;
	cast_message.ack_frame_id = 0;
	cast_message.missing_frames_and_packets[1].insert(3);
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10));
	transport_sender_->OnReceivedCastMessage(kVideoSsrc,
	RtcpCastMessageCallback(),
	cast_message);
	task_runner_->RunTasks();
	EXPECT_EQ(6, transport_.packets_sent());

	// Ack the second audio frame.
	cast_message.media_ssrc = kAudioSsrc;
	cast_message.ack_frame_id = 2;
	cast_message.missing_frames_and_packets.clear();
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
	transport_sender_->OnReceivedCastMessage(kAudioSsrc,
	RtcpCastMessageCallback(),
	cast_message);
	task_runner_->RunTasks();
	EXPECT_EQ(6, transport_.packets_sent());

	// Retransmission of video packet now accepted.
	cast_message.media_ssrc = kVideoSsrc;
	cast_message.ack_frame_id = 1;
	cast_message.missing_frames_and_packets[1].insert(3);
	task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2));
	transport_sender_->OnReceivedCastMessage(kVideoSsrc,
	RtcpCastMessageCallback(),
	cast_message);
	task_runner_->RunTasks();
	EXPECT_EQ(7, transport_.packets_sent());
	}

	} // namespace cast
	} // namespace media