#include "media/cast/cast_defines.h"
#include "media/cast/cast_environment.h"
#include "media/cast/rtcp/test_rtcp_packet_builder.h"
-#include "media/cast/test/fake_task_runner.h"
+#include "media/cast/test/fake_single_thread_task_runner.h"
#include "media/cast/transport/pacing/mock_paced_packet_sender.h"
#include "testing/gmock/include/gmock/gmock.h"
static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
namespace {
-class TestAudioEncoderCallback :
- public base::RefCountedThreadSafe<TestAudioEncoderCallback> {
+class TestAudioEncoderCallback
+ : public base::RefCountedThreadSafe<TestAudioEncoderCallback> {
public:
- TestAudioEncoderCallback()
- : num_called_(0) {}
+ TestAudioEncoderCallback() : num_called_(0) {}
void SetExpectedResult(uint8 expected_frame_id,
const base::TimeTicks& expected_playout_time) {
num_called_++;
}
- int number_times_called() const { return num_called_;}
+ int number_times_called() const { return num_called_; }
protected:
virtual ~TestAudioEncoderCallback() {}
int num_called_;
uint8 expected_frame_id_;
base::TimeTicks expected_playout_time_;
+
+ DISALLOW_COPY_AND_ASSIGN(TestAudioEncoderCallback);
};
} // namespace
testing_clock_ = new base::SimpleTestTickClock();
testing_clock_->Advance(
base::TimeDelta::FromMilliseconds(kStartMillisecond));
- task_runner_ = new test::FakeTaskRunner(testing_clock_);
+ task_runner_ = new test::FakeSingleThreadTaskRunner(testing_clock_);
+
+ CastLoggingConfig logging_config(GetDefaultCastReceiverLoggingConfig());
+ logging_config.enable_raw_data_collection = true;
+
cast_environment_ = new CastEnvironment(
scoped_ptr<base::TickClock>(testing_clock_).Pass(), task_runner_,
- task_runner_, task_runner_, task_runner_, task_runner_,
- task_runner_, GetDefaultCastReceiverLoggingConfig());
+ task_runner_, task_runner_, task_runner_, task_runner_, task_runner_,
+ logging_config);
+
test_audio_encoder_callback_ = new TestAudioEncoderCallback();
}
AudioReceiverConfig audio_config_;
std::vector<uint8> payload_;
RtpCastHeader rtp_header_;
- base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment.
+ base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment.
transport::MockPacedPacketSender mock_transport_;
- scoped_refptr<test::FakeTaskRunner> task_runner_;
+ scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
scoped_ptr<PeerAudioReceiver> receiver_;
scoped_refptr<CastEnvironment> cast_environment_;
scoped_refptr<TestAudioEncoderCallback> test_audio_encoder_callback_;
Configure(true);
EXPECT_CALL(mock_transport_, SendRtcpPacket(testing::_)).Times(1);
- receiver_->IncomingParsedRtpPacket(payload_.data(),
- payload_.size(), rtp_header_);
+ receiver_->IncomingParsedRtpPacket(payload_.data(), payload_.size(),
+ rtp_header_);
transport::EncodedAudioFrame audio_frame;
base::TimeTicks playout_time;
- test_audio_encoder_callback_->SetExpectedResult(
- 0, testing_clock_->NowTicks());
+ test_audio_encoder_callback_->SetExpectedResult(0,
+ testing_clock_->NowTicks());
AudioFrameEncodedCallback frame_encoded_callback =
base::Bind(&TestAudioEncoderCallback::DeliverEncodedAudioFrame,
TEST_F(AudioReceiverTest, MultiplePendingGetCalls) {
Configure(true);
- EXPECT_CALL(mock_transport_, SendRtcpPacket(testing::_)).WillRepeatedly(
- testing::Return(true));
+ EXPECT_CALL(mock_transport_, SendRtcpPacket(testing::_))
+ .WillRepeatedly(testing::Return(true));
AudioFrameEncodedCallback frame_encoded_callback =
base::Bind(&TestAudioEncoderCallback::DeliverEncodedAudioFrame,
transport::EncodedAudioFrame audio_frame;
base::TimeTicks playout_time;
- test_audio_encoder_callback_->SetExpectedResult(
- 0, testing_clock_->NowTicks());
+ test_audio_encoder_callback_->SetExpectedResult(0,
+ testing_clock_->NowTicks());
task_runner_->RunTasks();
EXPECT_EQ(1, test_audio_encoder_callback_->number_times_called());
uint32 ntp_low;
ConvertTimeTicksToNtp(testing_clock_->NowTicks(), &ntp_high, &ntp_low);
rtcp_packet.AddSrWithNtp(audio_config_.feedback_ssrc, ntp_high, ntp_low,
- rtp_header_.webrtc.header.timestamp);
+ rtp_header_.webrtc.header.timestamp);
testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
- receiver_->IncomingPacket(rtcp_packet.Packet(), rtcp_packet.Length(),
- base::Bind(AudioReceiverTest::DummyDeletePacket, rtcp_packet.Packet()));
+ receiver_->IncomingPacket(rtcp_packet.GetPacket().Pass());
// Make sure that we are not continuous and that the RTP timestamp represent a
// time in the future.
rtp_header_.is_reference = true;
rtp_header_.reference_frame_id = 0;
rtp_header_.webrtc.header.timestamp = 960;
- test_audio_encoder_callback_->SetExpectedResult(2,
- testing_clock_->NowTicks() + base::TimeDelta::FromMilliseconds(100));
+ test_audio_encoder_callback_->SetExpectedResult(
+ 2, testing_clock_->NowTicks() + base::TimeDelta::FromMilliseconds(100));
receiver_->IncomingParsedRtpPacket(payload_.data(), payload_.size(),
rtp_header_);
task_runner_->RunTasks();
EXPECT_EQ(2, test_audio_encoder_callback_->number_times_called());
- test_audio_encoder_callback_->SetExpectedResult(
- 3, testing_clock_->NowTicks());
+ test_audio_encoder_callback_->SetExpectedResult(3,
+ testing_clock_->NowTicks());
// Through on one more pending audio frame.
rtp_header_.frame_id = 3;
}
// TODO(mikhal): Add encoded frames.
-TEST_F(AudioReceiverTest, GetRawFrame) {
-}
+TEST_F(AudioReceiverTest, GetRawFrame) {}
} // namespace cast
} // namespace media