diff options
Diffstat (limited to 'chromium/media/cast/net')
26 files changed, 148 insertions, 141 deletions
diff --git a/chromium/media/cast/net/cast_transport_impl.h b/chromium/media/cast/net/cast_transport_impl.h index 12e7183c454..5c6fa889f19 100644 --- a/chromium/media/cast/net/cast_transport_impl.h +++ b/chromium/media/cast/net/cast_transport_impl.h @@ -60,6 +60,9 @@ class CastTransportImpl final : public CastTransport { std::unique_ptr<PacketTransport> transport, const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner); + CastTransportImpl(const CastTransportImpl&) = delete; + CastTransportImpl& operator=(const CastTransportImpl&) = delete; + ~CastTransportImpl() final; // CastTransport implementation for sending. @@ -184,8 +187,6 @@ class CastTransportImpl final : public CastTransport { SessionMap sessions_; base::WeakPtrFactory<CastTransportImpl> weak_factory_{this}; - - DISALLOW_COPY_AND_ASSIGN(CastTransportImpl); }; } // namespace cast diff --git a/chromium/media/cast/net/cast_transport_impl_unittest.cc b/chromium/media/cast/net/cast_transport_impl_unittest.cc index 32c1e5cb596..b38905a9575 100644 --- a/chromium/media/cast/net/cast_transport_impl_unittest.cc +++ b/chromium/media/cast/net/cast_transport_impl_unittest.cc @@ -90,8 +90,7 @@ class CastTransportImplTest : public ::testing::Test { protected: CastTransportImplTest() : num_times_logging_callback_called_(0) { - testing_clock_.Advance( - base::TimeDelta::FromMilliseconds(kStartMillisecond)); + testing_clock_.Advance(base::Milliseconds(kStartMillisecond)); task_runner_ = new FakeSingleThreadTaskRunner(&testing_clock_); } @@ -178,7 +177,7 @@ void CastTransportImplTest::InitWithOptions() { void CastTransportImplTest::InitWithLogging() { transport_ = new FakePacketSender(); transport_sender_ = std::make_unique<CastTransportImpl>( - &testing_clock_, base::TimeDelta::FromMilliseconds(10), + &testing_clock_, base::Milliseconds(10), std::make_unique<TransportClient>(this), base::WrapUnique(transport_), task_runner_); task_runner_->RunTasks(); @@ -186,20 +185,20 @@ void CastTransportImplTest::InitWithLogging() { TEST_F(CastTransportImplTest, InitWithoutLogging) { InitWithoutLogging(); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); + task_runner_->Sleep(base::Milliseconds(50)); EXPECT_EQ(0, num_times_logging_callback_called_); } TEST_F(CastTransportImplTest, InitWithOptions) { InitWithOptions(); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); + task_runner_->Sleep(base::Milliseconds(50)); EXPECT_EQ(0, num_times_logging_callback_called_); } TEST_F(CastTransportImplTest, NacksCancelRetransmits) { InitWithLogging(); InitializeVideo(); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); + task_runner_->Sleep(base::Milliseconds(50)); EXPECT_EQ(0, num_times_logging_callback_called_); // A fake frame that will be decomposed into 4 packets. @@ -211,7 +210,7 @@ TEST_F(CastTransportImplTest, NacksCancelRetransmits) { fake_frame.data.resize(5000, ' '); transport_sender_->InsertFrame(kVideoSsrc, fake_frame); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); + task_runner_->Sleep(base::Milliseconds(10)); EXPECT_EQ(4, transport_->packets_sent()); EXPECT_EQ(1, num_times_logging_callback_called_); @@ -223,11 +222,11 @@ TEST_F(CastTransportImplTest, NacksCancelRetransmits) { transport_->SetPaused(true); DedupInfo dedup_info; - dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10); + dedup_info.resend_interval = base::Milliseconds(10); transport_sender_->ResendPackets(kVideoSsrc, missing_packets, true, dedup_info); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); + task_runner_->Sleep(base::Milliseconds(10)); EXPECT_EQ(2, num_times_logging_callback_called_); RtcpCastMessage cast_message; @@ -236,7 +235,7 @@ TEST_F(CastTransportImplTest, NacksCancelRetransmits) { cast_message.missing_frames_and_packets[fake_frame.frame_id].insert(3); transport_sender_->OnReceivedCastMessage(kVideoSsrc, cast_message); transport_->SetPaused(false); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); + task_runner_->Sleep(base::Milliseconds(10)); EXPECT_EQ(3, num_times_logging_callback_called_); // Resend one packet in the socket when unpaused. @@ -247,7 +246,7 @@ TEST_F(CastTransportImplTest, NacksCancelRetransmits) { TEST_F(CastTransportImplTest, CancelRetransmits) { InitWithLogging(); InitializeVideo(); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); + task_runner_->Sleep(base::Milliseconds(50)); EXPECT_EQ(0, num_times_logging_callback_called_); // A fake frame that will be decomposed into 4 packets. @@ -259,7 +258,7 @@ TEST_F(CastTransportImplTest, CancelRetransmits) { fake_frame.data.resize(5000, ' '); transport_sender_->InsertFrame(kVideoSsrc, fake_frame); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); + task_runner_->Sleep(base::Milliseconds(10)); EXPECT_EQ(4, transport_->packets_sent()); EXPECT_EQ(1, num_times_logging_callback_called_); @@ -269,18 +268,18 @@ TEST_F(CastTransportImplTest, CancelRetransmits) { transport_->SetPaused(true); DedupInfo dedup_info; - dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10); + dedup_info.resend_interval = base::Milliseconds(10); transport_sender_->ResendPackets(kVideoSsrc, missing_packets, true, dedup_info); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); + task_runner_->Sleep(base::Milliseconds(10)); EXPECT_EQ(2, num_times_logging_callback_called_); std::vector<FrameId> cancel_sending_frames; cancel_sending_frames.push_back(fake_frame.frame_id); transport_sender_->CancelSendingFrames(kVideoSsrc, cancel_sending_frames); transport_->SetPaused(false); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); + task_runner_->Sleep(base::Milliseconds(10)); EXPECT_EQ(2, num_times_logging_callback_called_); // Resend one packet in the socket when unpaused. @@ -290,7 +289,7 @@ TEST_F(CastTransportImplTest, CancelRetransmits) { TEST_F(CastTransportImplTest, Kickstart) { InitWithLogging(); InitializeVideo(); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); + task_runner_->Sleep(base::Milliseconds(50)); EXPECT_EQ(0, num_times_logging_callback_called_); // A fake frame that will be decomposed into 4 packets. @@ -305,7 +304,7 @@ TEST_F(CastTransportImplTest, Kickstart) { transport_sender_->InsertFrame(kVideoSsrc, fake_frame); transport_sender_->ResendFrameForKickstart(kVideoSsrc, fake_frame.frame_id); transport_->SetPaused(false); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); + task_runner_->Sleep(base::Milliseconds(10)); EXPECT_EQ(4, transport_->packets_sent()); EXPECT_EQ(1, num_times_logging_callback_called_); @@ -316,12 +315,12 @@ TEST_F(CastTransportImplTest, Kickstart) { transport_->SetPaused(true); DedupInfo dedup_info; - dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10); + dedup_info.resend_interval = base::Milliseconds(10); transport_sender_->ResendPackets(kVideoSsrc, missing_packets, true, dedup_info); transport_sender_->ResendFrameForKickstart(kVideoSsrc, fake_frame.frame_id); transport_->SetPaused(false); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); + task_runner_->Sleep(base::Milliseconds(10)); EXPECT_EQ(2, num_times_logging_callback_called_); // Resend one packet in the socket when unpaused. @@ -333,7 +332,7 @@ TEST_F(CastTransportImplTest, DedupRetransmissionWithAudio) { InitWithLogging(); InitializeAudio(); InitializeVideo(); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); + task_runner_->Sleep(base::Milliseconds(50)); EXPECT_EQ(0, num_times_logging_callback_called_); // Send two audio frames. @@ -344,11 +343,11 @@ TEST_F(CastTransportImplTest, DedupRetransmissionWithAudio) { fake_audio.dependency = EncodedFrame::KEY; fake_audio.data.resize(100, ' '); transport_sender_->InsertFrame(kAudioSsrc, fake_audio); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); + task_runner_->Sleep(base::Milliseconds(2)); fake_audio.frame_id = FrameId::first() + 2; fake_audio.reference_time = testing_clock_.NowTicks(); transport_sender_->InsertFrame(kAudioSsrc, fake_audio); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); + task_runner_->Sleep(base::Milliseconds(2)); EXPECT_EQ(2, transport_->packets_sent()); // Ack the first audio frame. @@ -375,7 +374,7 @@ TEST_F(CastTransportImplTest, DedupRetransmissionWithAudio) { cast_message.remote_ssrc = kVideoSsrc; cast_message.ack_frame_id = FrameId::first(); cast_message.missing_frames_and_packets[fake_video.frame_id].insert(3); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); + task_runner_->Sleep(base::Milliseconds(10)); transport_sender_->OnReceivedCastMessage(kVideoSsrc, cast_message); task_runner_->RunTasks(); EXPECT_EQ(6, transport_->packets_sent()); @@ -385,7 +384,7 @@ TEST_F(CastTransportImplTest, DedupRetransmissionWithAudio) { cast_message.remote_ssrc = kAudioSsrc; cast_message.ack_frame_id = FrameId::first() + 2; cast_message.missing_frames_and_packets.clear(); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); + task_runner_->Sleep(base::Milliseconds(2)); transport_sender_->OnReceivedCastMessage(kAudioSsrc, cast_message); task_runner_->RunTasks(); EXPECT_EQ(6, transport_->packets_sent()); @@ -395,13 +394,13 @@ TEST_F(CastTransportImplTest, DedupRetransmissionWithAudio) { cast_message.remote_ssrc = kVideoSsrc; cast_message.ack_frame_id = FrameId::first() + 1; cast_message.missing_frames_and_packets[fake_video.frame_id].insert(3); - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); + task_runner_->Sleep(base::Milliseconds(2)); transport_sender_->OnReceivedCastMessage(kVideoSsrc, cast_message); task_runner_->RunTasks(); EXPECT_EQ(7, transport_->packets_sent()); EXPECT_EQ(1, num_times_logging_callback_called_); // Only 8 ms since last. - task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); + task_runner_->Sleep(base::Milliseconds(2)); EXPECT_EQ(2, num_times_logging_callback_called_); } diff --git a/chromium/media/cast/net/pacing/paced_sender.cc b/chromium/media/cast/net/pacing/paced_sender.cc index 62317fc0267..09a815c7df8 100644 --- a/chromium/media/cast/net/pacing/paced_sender.cc +++ b/chromium/media/cast/net/pacing/paced_sender.cc @@ -334,7 +334,7 @@ void PacedSender::SendStoredPackets() { if (now >= burst_end_ || previous_state == State_BurstFull) { // Start a new burst. current_burst_size_ = 0; - burst_end_ = now + base::TimeDelta::FromMilliseconds(kPacingIntervalMs); + burst_end_ = now + base::Milliseconds(kPacingIntervalMs); // The goal here is to try to send out the queued packets over the next // three bursts, while trying to keep the burst size below 10 if possible. diff --git a/chromium/media/cast/net/pacing/paced_sender.h b/chromium/media/cast/net/pacing/paced_sender.h index 7dedb1c62b0..1c4ef0ee276 100644 --- a/chromium/media/cast/net/pacing/paced_sender.h +++ b/chromium/media/cast/net/pacing/paced_sender.h @@ -109,6 +109,9 @@ class PacedSender final : public PacedPacketSender { PacketTransport* external_transport, const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner); + PacedSender(const PacedSender&) = delete; + PacedSender& operator=(const PacedSender&) = delete; + ~PacedSender() final; // These must be called before non-RTCP packets are sent. @@ -241,8 +244,6 @@ class PacedSender final : public PacedPacketSender { // NOTE: Weak pointers must be invalidated before all other member variables. base::WeakPtrFactory<PacedSender> weak_factory_{this}; - - DISALLOW_COPY_AND_ASSIGN(PacedSender); }; } // namespace cast diff --git a/chromium/media/cast/net/pacing/paced_sender_unittest.cc b/chromium/media/cast/net/pacing/paced_sender_unittest.cc index 84cb6f6244b..ad1fc808eb2 100644 --- a/chromium/media/cast/net/pacing/paced_sender_unittest.cc +++ b/chromium/media/cast/net/pacing/paced_sender_unittest.cc @@ -93,8 +93,7 @@ class TestPacketSender : public PacketTransport { class PacedSenderTest : public ::testing::Test { protected: PacedSenderTest() { - testing_clock_.Advance( - base::TimeDelta::FromMilliseconds(kStartMillisecond)); + testing_clock_.Advance(base::Milliseconds(kStartMillisecond)); task_runner_ = new FakeSingleThreadTaskRunner(&testing_clock_); paced_sender_ = std::make_unique<PacedSender>( kTargetBurstSize, kMaxBurstSize, &testing_clock_, &packet_events_, @@ -115,7 +114,7 @@ class PacedSenderTest : public ::testing::Test { base::TimeTicks frame_tick = testing_clock_.NowTicks(); // Advance the clock so that we don't get the same |frame_tick| // next time this function is called. - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(1)); + testing_clock_.Advance(base::Milliseconds(1)); for (int i = 0; i < num_of_packets_in_frame; ++i) { PacketKey key(frame_tick, audio ? kAudioSsrc : kVideoSsrc, FrameId::first(), i); @@ -146,7 +145,7 @@ class PacedSenderTest : public ::testing::Test { packets.begin() + i, packets.begin() + i + std::min(packets.size() - i, kBatchSize)); ASSERT_TRUE(paced_sender_->SendPackets(next_batch)); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10)); + testing_clock_.Advance(base::Milliseconds(10)); task_runner_->RunTasks(); } } @@ -155,7 +154,7 @@ class PacedSenderTest : public ::testing::Test { // to test the pacing implementation details. bool RunUntilEmpty(int max_tries) { for (int i = 0; i < max_tries; i++) { - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10)); + testing_clock_.Advance(base::Milliseconds(10)); task_runner_->RunTasks(); if (mock_transport_.expecting_nothing_else()) return true; @@ -201,12 +200,12 @@ TEST_F(PacedSenderTest, BasicPace) { // Check that we get the next burst. mock_transport_.AddExpectedSizesAndPacketIds(kSize1, UINT16_C(10), 10); - base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10); + base::TimeDelta timeout = base::Milliseconds(10); testing_clock_.Advance(timeout); task_runner_->RunTasks(); // If we call process too early make sure we don't send any packets. - timeout = base::TimeDelta::FromMilliseconds(5); + timeout = base::Milliseconds(5); testing_clock_.Advance(timeout); task_runner_->RunTasks(); @@ -258,7 +257,7 @@ TEST_F(PacedSenderTest, PaceWithNack) { // Check that we get the first NACK burst. mock_transport_.AddExpectedSizesAndPacketIds(kNackSize, UINT16_C(0), 10); - base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10); + base::TimeDelta timeout = base::Milliseconds(10); testing_clock_.Advance(timeout); task_runner_->RunTasks(); @@ -338,7 +337,7 @@ TEST_F(PacedSenderTest, PaceWith60fps) { SendPacketVector fourth_frame_packets = CreateSendPacketVector(kSize4, num_of_packets_in_frame, false); - base::TimeDelta timeout_10ms = base::TimeDelta::FromMilliseconds(10); + base::TimeDelta timeout_10ms = base::Milliseconds(10); // Check that the first burst of the frame go out on the wire. mock_transport_.AddExpectedSizesAndPacketIds(kSize1, UINT16_C(0), 10); @@ -348,12 +347,12 @@ TEST_F(PacedSenderTest, PaceWith60fps) { testing_clock_.Advance(timeout_10ms); task_runner_->RunTasks(); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(6)); + testing_clock_.Advance(base::Milliseconds(6)); // Add second frame, after 16 ms. mock_transport_.AddExpectedSizesAndPacketIds(kSize2, UINT16_C(0), 3); EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets)); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(4)); + testing_clock_.Advance(base::Milliseconds(4)); mock_transport_.AddExpectedSizesAndPacketIds(kSize2, UINT16_C(3), 10); testing_clock_.Advance(timeout_10ms); @@ -363,14 +362,14 @@ TEST_F(PacedSenderTest, PaceWith60fps) { testing_clock_.Advance(timeout_10ms); task_runner_->RunTasks(); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(3)); + testing_clock_.Advance(base::Milliseconds(3)); // Add third frame, after 33 ms. mock_transport_.AddExpectedSizesAndPacketIds(kSize3, UINT16_C(0), 6); EXPECT_TRUE(paced_sender_->SendPackets(third_frame_packets)); mock_transport_.AddExpectedSizesAndPacketIds(kSize3, UINT16_C(6), 10); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(7)); + testing_clock_.Advance(base::Milliseconds(7)); task_runner_->RunTasks(); // Add fourth frame, after 50 ms. @@ -412,14 +411,14 @@ TEST_F(PacedSenderTest, SendPriority) { // Retransmission packets with the earlier timestamp. SendPacketVector resend_packets = CreateSendPacketVector(kSize4, 10, false); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10)); + testing_clock_.Advance(base::Milliseconds(10)); // Send 20 normal video packets. Only 10 will be sent in this // call, the rest will be sitting in the queue waiting for pacing. EXPECT_TRUE( paced_sender_->SendPackets(CreateSendPacketVector(kSize2, 20, false))); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10)); + testing_clock_.Advance(base::Milliseconds(10)); // Send normal audio packet. This is queued and will be sent // earlier than video packets. @@ -487,16 +486,16 @@ TEST_F(PacedSenderTest, DedupWithResendInterval) { SendPacketVector packets = CreateSendPacketVector(kSize1, 1, true); mock_transport_.AddExpectedSizesAndPacketIds(kSize1, UINT16_C(0), 1); EXPECT_TRUE(paced_sender_->SendPackets(packets)); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10)); + testing_clock_.Advance(base::Milliseconds(10)); DedupInfo dedup_info; - dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(20); + dedup_info.resend_interval = base::Milliseconds(20); // This packet will not be sent. EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info)); EXPECT_EQ(static_cast<int64_t>(kSize1), mock_transport_.GetBytesSent()); - dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(5); + dedup_info.resend_interval = base::Milliseconds(5); mock_transport_.AddExpectedSizesAndPacketIds(kSize1, UINT16_C(0), 1); EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info)); EXPECT_EQ(static_cast<int64_t>(2 * kSize1), mock_transport_.GetBytesSent()); diff --git a/chromium/media/cast/net/rtcp/receiver_rtcp_event_subscriber.h b/chromium/media/cast/net/rtcp/receiver_rtcp_event_subscriber.h index d299698124f..3305aef6cfa 100644 --- a/chromium/media/cast/net/rtcp/receiver_rtcp_event_subscriber.h +++ b/chromium/media/cast/net/rtcp/receiver_rtcp_event_subscriber.h @@ -47,6 +47,10 @@ class ReceiverRtcpEventSubscriber final : public RawEventSubscriber { ReceiverRtcpEventSubscriber(const size_t max_size_to_retain, EventMediaType type); + ReceiverRtcpEventSubscriber(const ReceiverRtcpEventSubscriber&) = delete; + ReceiverRtcpEventSubscriber& operator=(const ReceiverRtcpEventSubscriber&) = + delete; + ~ReceiverRtcpEventSubscriber() final; // RawEventSubscriber implementation. @@ -96,8 +100,6 @@ class ReceiverRtcpEventSubscriber final : public RawEventSubscriber { // Ensures methods are only called on the main thread. base::ThreadChecker thread_checker_; - - DISALLOW_COPY_AND_ASSIGN(ReceiverRtcpEventSubscriber); }; } // namespace cast diff --git a/chromium/media/cast/net/rtcp/receiver_rtcp_event_subscriber_unittest.cc b/chromium/media/cast/net/rtcp/receiver_rtcp_event_subscriber_unittest.cc index 9345660494b..dfc4cbe5d93 100644 --- a/chromium/media/cast/net/rtcp/receiver_rtcp_event_subscriber_unittest.cc +++ b/chromium/media/cast/net/rtcp/receiver_rtcp_event_subscriber_unittest.cc @@ -60,7 +60,7 @@ class ReceiverRtcpEventSubscriberTest : public ::testing::Test { playout_event->media_type = VIDEO_EVENT; playout_event->rtp_timestamp = RtpTimeTicks().Expand(UINT32_C(100)); playout_event->frame_id = FrameId::first() + 2; - playout_event->delay_delta = base::TimeDelta::FromMilliseconds(kDelayMs); + playout_event->delay_delta = base::Milliseconds(kDelayMs); cast_environment_->logger()->DispatchFrameEvent(std::move(playout_event)); std::unique_ptr<FrameEvent> decode_event(new FrameEvent()); @@ -89,7 +89,7 @@ class ReceiverRtcpEventSubscriberTest : public ::testing::Test { playout_event->media_type = AUDIO_EVENT; playout_event->rtp_timestamp = RtpTimeTicks().Expand(UINT32_C(300)); playout_event->frame_id = FrameId::first() + 4; - playout_event->delay_delta = base::TimeDelta::FromMilliseconds(kDelayMs); + playout_event->delay_delta = base::Milliseconds(kDelayMs); cast_environment_->logger()->DispatchFrameEvent(std::move(playout_event)); decode_event = std::make_unique<FrameEvent>(); diff --git a/chromium/media/cast/net/rtcp/receiver_rtcp_session.cc b/chromium/media/cast/net/rtcp/receiver_rtcp_session.cc index 3544cbd8023..547a1e733c0 100644 --- a/chromium/media/cast/net/rtcp/receiver_rtcp_session.cc +++ b/chromium/media/cast/net/rtcp/receiver_rtcp_session.cc @@ -109,8 +109,7 @@ bool ReceiverRtcpSession::GetLatestLipSyncTimes( local_clock_ahead_by_.Current(); // Sanity-check: Getting regular lip sync updates? - DCHECK((clock_->NowTicks() - local_reference_time) < - base::TimeDelta::FromMinutes(1)); + DCHECK((clock_->NowTicks() - local_reference_time) < base::Minutes(1)); *rtp_timestamp = lip_sync_rtp_timestamp_; *reference_time = local_reference_time; diff --git a/chromium/media/cast/net/rtcp/receiver_rtcp_session.h b/chromium/media/cast/net/rtcp/receiver_rtcp_session.h index 166f91b6304..579a4d2ff13 100644 --- a/chromium/media/cast/net/rtcp/receiver_rtcp_session.h +++ b/chromium/media/cast/net/rtcp/receiver_rtcp_session.h @@ -25,6 +25,9 @@ class ReceiverRtcpSession : public RtcpSession { uint32_t local_ssrc, uint32_t remote_ssrc); + ReceiverRtcpSession(const ReceiverRtcpSession&) = delete; + ReceiverRtcpSession& operator=(const ReceiverRtcpSession&) = delete; + ~ReceiverRtcpSession() override; uint32_t local_ssrc() const { return local_ssrc_; } @@ -88,8 +91,6 @@ class ReceiverRtcpSession : public RtcpSession { // remembers state about prior RTP timestamps and other sequence values to // re-construct "expanded" values. RtcpParser parser_; - - DISALLOW_COPY_AND_ASSIGN(ReceiverRtcpSession); }; } // namespace cast diff --git a/chromium/media/cast/net/rtcp/rtcp_builder.h b/chromium/media/cast/net/rtcp/rtcp_builder.h index 10bd90475ff..95c746d0599 100644 --- a/chromium/media/cast/net/rtcp/rtcp_builder.h +++ b/chromium/media/cast/net/rtcp/rtcp_builder.h @@ -21,6 +21,10 @@ namespace cast { class RtcpBuilder { public: explicit RtcpBuilder(uint32_t sending_ssrc); + + RtcpBuilder(const RtcpBuilder&) = delete; + RtcpBuilder& operator=(const RtcpBuilder&) = delete; + ~RtcpBuilder(); PacketRef BuildRtcpFromSender(const RtcpSenderInfo& sender_info); @@ -52,8 +56,6 @@ class RtcpBuilder { const uint32_t local_ssrc_; char* ptr_of_length_; PacketRef packet_; - - DISALLOW_COPY_AND_ASSIGN(RtcpBuilder); }; } // namespace cast diff --git a/chromium/media/cast/net/rtcp/rtcp_builder_unittest.cc b/chromium/media/cast/net/rtcp/rtcp_builder_unittest.cc index 8b2cc117bb9..a75410c6a2a 100644 --- a/chromium/media/cast/net/rtcp/rtcp_builder_unittest.cc +++ b/chromium/media/cast/net/rtcp/rtcp_builder_unittest.cc @@ -26,8 +26,7 @@ namespace cast { namespace { static const uint32_t kSendingSsrc = 0x12345678; static const uint32_t kMediaSsrc = 0x87654321; -static const base::TimeDelta kDefaultDelay = - base::TimeDelta::FromMilliseconds(100); +static const base::TimeDelta kDefaultDelay = base::Milliseconds(100); RtcpReportBlock GetReportBlock() { RtcpReportBlock report_block; @@ -227,7 +226,7 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) { nullptr, &rtcp_events, kDefaultDelay)); base::SimpleTestTickClock testing_clock; - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); + testing_clock.Advance(base::Milliseconds(kTimeBaseMs)); p.AddReceiverLog(kSendingSsrc); p.AddReceiverFrameLog(test_rtp_timestamp().lower_32_bits(), 2, kTimeBaseMs); @@ -240,7 +239,7 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) { frame_event.media_type = VIDEO_EVENT; frame_event.timestamp = testing_clock.NowTicks(); event_subscriber.OnReceiveFrameEvent(frame_event); - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); + testing_clock.Advance(base::Milliseconds(kTimeDelayMs)); PacketEvent packet_event; packet_event.rtp_timestamp = test_rtp_timestamp(); @@ -268,7 +267,7 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOversizedFrameLog) { RtcpReportBlock report_block = GetReportBlock(); base::SimpleTestTickClock testing_clock; - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); + testing_clock.Advance(base::Milliseconds(kTimeBaseMs)); p.AddReceiverLog(kSendingSsrc); @@ -296,7 +295,7 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOversizedFrameLog) { packet_event.timestamp = testing_clock.NowTicks(); packet_event.packet_id = kLostPacketId1; event_subscriber.OnReceivePacketEvent(packet_event); - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); + testing_clock.Advance(base::Milliseconds(kTimeDelayMs)); } ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; @@ -318,7 +317,7 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportWithTooManyLogFrames) { RtcpReportBlock report_block = GetReportBlock(); base::SimpleTestTickClock testing_clock; - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); + testing_clock.Advance(base::Milliseconds(kTimeBaseMs)); p.AddReceiverLog(kSendingSsrc); @@ -341,7 +340,7 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportWithTooManyLogFrames) { frame_event.media_type = VIDEO_EVENT; frame_event.timestamp = testing_clock.NowTicks(); event_subscriber.OnReceiveFrameEvent(frame_event); - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); + testing_clock.Advance(base::Milliseconds(kTimeDelayMs)); } ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; @@ -362,7 +361,7 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOldLogFrames) { RtcpReportBlock report_block = GetReportBlock(); base::SimpleTestTickClock testing_clock; - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); + testing_clock.Advance(base::Milliseconds(kTimeBaseMs)); p.AddReceiverLog(kSendingSsrc); @@ -384,8 +383,7 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOldLogFrames) { frame_event.media_type = VIDEO_EVENT; frame_event.timestamp = testing_clock.NowTicks(); event_subscriber.OnReceiveFrameEvent(frame_event); - testing_clock.Advance( - base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs)); + testing_clock.Advance(base::Milliseconds(kTimeBetweenEventsMs)); } ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events; @@ -403,7 +401,7 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportRedundancy) { RtcpReportBlock report_block = GetReportBlock(); base::SimpleTestTickClock testing_clock; - testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms)); + testing_clock.Advance(base::Milliseconds(time_base_ms)); ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); size_t packet_count = kNumResends * kResendDelay + 10; @@ -419,9 +417,9 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportRedundancy) { p.AddReceiverFrameLog(test_rtp_timestamp().lower_32_bits(), num_events, time_base_ms - (num_events - 1) * kResendDelay * kTimeBetweenEventsMs); - for (int i = 0; i < num_events; i++) { + for (int event = 0; event < num_events; event++) { p.AddReceiverEventLog(0, FRAME_ACK_SENT, - base::checked_cast<uint16_t>(i * kResendDelay * + base::checked_cast<uint16_t>(event * kResendDelay * kTimeBetweenEventsMs)); } @@ -439,8 +437,7 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportRedundancy) { BuildRtcpFromReceiver(&report_block, nullptr, nullptr, nullptr, &rtcp_events, kDefaultDelay)); - testing_clock.Advance( - base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs)); + testing_clock.Advance(base::Milliseconds(kTimeBetweenEventsMs)); time_base_ms += kTimeBetweenEventsMs; } } diff --git a/chromium/media/cast/net/rtcp/rtcp_unittest.cc b/chromium/media/cast/net/rtcp/rtcp_unittest.cc index ed2fab8ef8e..db53457c3b1 100644 --- a/chromium/media/cast/net/rtcp/rtcp_unittest.cc +++ b/chromium/media/cast/net/rtcp/rtcp_unittest.cc @@ -41,7 +41,7 @@ static const uint16_t kTargetDelayMs = 100; class FakeRtcpTransport : public PacedPacketSender { public: explicit FakeRtcpTransport(base::SimpleTestTickClock* clock) - : clock_(clock), packet_delay_(base::TimeDelta::FromMilliseconds(42)) {} + : clock_(clock), packet_delay_(base::Milliseconds(42)) {} void set_rtcp_destination(RtcpSession* rtcp_session) { rtcp_session_ = rtcp_session; @@ -92,9 +92,8 @@ class RtcpTest : public ::testing::Test, public RtcpObserver { kSenderSsrc), received_pli_(false) { sender_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); - receiver_clock_->SetSkew( - 1.0, // No skew. - base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds)); + receiver_clock_->SetSkew(1.0, // No skew. + base::Seconds(kInitialReceiverClockOffsetSeconds)); rtp_sender_pacer_.set_rtcp_destination(&rtcp_at_rtp_receiver_); rtp_receiver_pacer_.set_rtcp_destination(&rtcp_at_rtp_sender_); @@ -215,7 +214,7 @@ TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) { const base::TimeTicks rolled_back_time = (reference_time - // Roll-back relative clock offset: - base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds) - + base::Seconds(kInitialReceiverClockOffsetSeconds) - // Roll-back packet transmission time (because RTT is not yet known): rtp_sender_pacer_.packet_delay()); EXPECT_NEAR(0, (reference_time_sent - rolled_back_time).InMicroseconds(), 5); @@ -233,7 +232,7 @@ TEST_F(RtcpTest, RoundTripTimesDeterminedFromReportPingPong) { base::TimeDelta expected_rtt_according_to_sender; for (int i = 0; i < iterations; ++i) { const base::TimeDelta one_way_trip_time = - base::TimeDelta::FromMilliseconds(static_cast<int64_t>(1) << i); + base::Milliseconds(static_cast<int64_t>(1) << i); rtp_sender_pacer_.set_packet_delay(one_way_trip_time); rtp_receiver_pacer_.set_packet_delay(one_way_trip_time); @@ -282,7 +281,7 @@ TEST_F(RtcpTest, ReportCastFeedback) { rtcp_at_rtp_receiver_.local_ssrc(), BuildRtcpPacketFromRtpReceiver( CreateRtcpTimeData(base::TimeTicks()), &cast_message, nullptr, - base::TimeDelta::FromMilliseconds(kTargetDelayMs), nullptr, nullptr)); + base::Milliseconds(kTargetDelayMs), nullptr, nullptr)); EXPECT_EQ(last_cast_message_.ack_frame_id, cast_message.ack_frame_id); EXPECT_EQ(last_cast_message_.target_delay_ms, kTargetDelayMs); @@ -315,8 +314,7 @@ TEST_F(RtcpTest, DropLateRtcpPacket) { rtcp_at_rtp_receiver_.local_ssrc(), BuildRtcpPacketFromRtpReceiver( CreateRtcpTimeData(receiver_clock_->NowTicks()), &cast_message, - nullptr, base::TimeDelta::FromMilliseconds(kTargetDelayMs), nullptr, - nullptr)); + nullptr, base::Milliseconds(kTargetDelayMs), nullptr, nullptr)); // Receiver ACKs first+2, but with a too-old timestamp. RtcpCastMessage late_cast_message(kSenderSsrc); @@ -324,8 +322,7 @@ TEST_F(RtcpTest, DropLateRtcpPacket) { rtp_receiver_pacer_.SendRtcpPacket( rtcp_at_rtp_receiver_.local_ssrc(), BuildRtcpPacketFromRtpReceiver( - CreateRtcpTimeData(receiver_clock_->NowTicks() - - base::TimeDelta::FromSeconds(10)), + CreateRtcpTimeData(receiver_clock_->NowTicks() - base::Seconds(10)), &late_cast_message, nullptr, base::TimeDelta(), nullptr, nullptr)); // Validate data from second packet is dropped. @@ -347,7 +344,7 @@ TEST_F(RtcpTest, ReportReceiverEvents) { const RtpTimeTicks kRtpTimeStamp = media::cast::RtpTimeTicks().Expand(UINT32_C(100)); const base::TimeTicks kEventTimestamp = receiver_clock_->NowTicks(); - const base::TimeDelta kDelayDelta = base::TimeDelta::FromMilliseconds(100); + const base::TimeDelta kDelayDelta = base::Milliseconds(100); RtcpEvent event; event.type = FRAME_ACK_SENT; diff --git a/chromium/media/cast/net/rtcp/rtcp_utility.cc b/chromium/media/cast/net/rtcp/rtcp_utility.cc index 2cc8ca56e20..98ead3da373 100644 --- a/chromium/media/cast/net/rtcp/rtcp_utility.cc +++ b/chromium/media/cast/net/rtcp/rtcp_utility.cc @@ -252,8 +252,8 @@ bool RtcpParser::ParseCastReceiverLogFrameItem( return false; // We have 24 LSB of the event timestamp base on the wire. - base::TimeTicks event_timestamp_base = base::TimeTicks() + - base::TimeDelta::FromMilliseconds(data & 0xffffff); + base::TimeTicks event_timestamp_base = + base::TimeTicks() + base::Milliseconds(data & 0xffffff); size_t num_events = 1 + static_cast<uint8_t>(data >> 24); @@ -272,13 +272,12 @@ bool RtcpParser::ParseCastReceiverLogFrameItem( static_cast<uint8_t>(event_type_and_timestamp_delta >> 12)); event_log.event_timestamp = event_timestamp_base + - base::TimeDelta::FromMilliseconds( - event_type_and_timestamp_delta & 0xfff); + base::Milliseconds(event_type_and_timestamp_delta & 0xfff); if (event_log.type == PACKET_RECEIVED) { event_log.packet_id = delay_delta_or_packet_id; } else { - event_log.delay_delta = base::TimeDelta::FromMilliseconds( - static_cast<int16_t>(delay_delta_or_packet_id)); + event_log.delay_delta = + base::Milliseconds(static_cast<int16_t>(delay_delta_or_packet_id)); } frame_log.event_log_messages_.push_back(event_log); } @@ -526,9 +525,9 @@ base::TimeTicks ConvertNtpToTimeTicks(uint32_t ntp_seconds, ntp_seconds * base::Time::kMicrosecondsPerSecond + static_cast<int64_t>(std::ceil(ntp_fractions / kMagicFractionalUnit)); - base::TimeDelta elapsed_since_unix_epoch = base::TimeDelta::FromMicroseconds( - ntp_time_us - - (kUnixEpochInNtpSeconds * base::Time::kMicrosecondsPerSecond)); + base::TimeDelta elapsed_since_unix_epoch = + base::Microseconds(ntp_time_us - (kUnixEpochInNtpSeconds * + base::Time::kMicrosecondsPerSecond)); return base::TimeTicks::UnixEpoch() + elapsed_since_unix_epoch; } diff --git a/chromium/media/cast/net/rtcp/rtcp_utility.h b/chromium/media/cast/net/rtcp/rtcp_utility.h index 9a10ecae523..667352529e3 100644 --- a/chromium/media/cast/net/rtcp/rtcp_utility.h +++ b/chromium/media/cast/net/rtcp/rtcp_utility.h @@ -40,6 +40,10 @@ struct RtcpCommonHeader { class RtcpParser { public: RtcpParser(uint32_t local_ssrc, uint32_t remote_ssrc); + + RtcpParser(const RtcpParser&) = delete; + RtcpParser& operator=(const RtcpParser&) = delete; + ~RtcpParser(); // Gets/Sets the ID of the latest frame that could possibly be ACK'ed. This @@ -132,8 +136,6 @@ class RtcpParser { // Indicates if sender received the Pli message from the receiver. bool has_picture_loss_indicator_; - - DISALLOW_COPY_AND_ASSIGN(RtcpParser); }; // Converts a log event type to an integer value. diff --git a/chromium/media/cast/net/rtcp/rtcp_utility_unittest.cc b/chromium/media/cast/net/rtcp/rtcp_utility_unittest.cc index 915ff3c29fd..f4d3d08e59a 100644 --- a/chromium/media/cast/net/rtcp/rtcp_utility_unittest.cc +++ b/chromium/media/cast/net/rtcp/rtcp_utility_unittest.cc @@ -22,8 +22,7 @@ namespace cast { static const uint32_t kRemoteSsrc = 0x10203; static const uint32_t kLocalSsrc = 0x40506; static const uint32_t kUnknownSsrc = 0xDEAD; -static const base::TimeDelta kTargetDelay = - base::TimeDelta::FromMilliseconds(100); +static const base::TimeDelta kTargetDelay = base::Milliseconds(100); class RtcpParserTest : public ::testing::Test { protected: @@ -434,7 +433,7 @@ TEST_F(RtcpParserTest, InjectReceiverReportWithReceiverLogVerificationBase) { static const uint32_t kTimeDelayMs = 10; static const uint32_t kDelayDeltaMs = 123; base::SimpleTestTickClock testing_clock; - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); + testing_clock.Advance(base::Milliseconds(kTimeBaseMs)); RtcpReceiverLogMessage receiver_log; RtcpReceiverFrameLogMessage frame_log(RtpTimeTicks().Expand(kRtpTimestamp)); @@ -442,10 +441,10 @@ TEST_F(RtcpParserTest, InjectReceiverReportWithReceiverLogVerificationBase) { event_log.type = FRAME_ACK_SENT; event_log.event_timestamp = testing_clock.NowTicks(); - event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); + event_log.delay_delta = base::Milliseconds(kDelayDeltaMs); frame_log.event_log_messages_.push_back(event_log); - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); + testing_clock.Advance(base::Milliseconds(kTimeDelayMs)); event_log.type = PACKET_RECEIVED; event_log.event_timestamp = testing_clock.NowTicks(); event_log.packet_id = kLostPacketId1; @@ -477,7 +476,7 @@ TEST_F(RtcpParserTest, InjectReceiverReportWithReceiverLogVerificationMulti) { static const uint32_t kTimeDelayMs = 10; static const int kDelayDeltaMs = 123; // To be varied for every frame. base::SimpleTestTickClock testing_clock; - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); + testing_clock.Advance(base::Milliseconds(kTimeBaseMs)); RtcpReceiverLogMessage receiver_log; @@ -486,11 +485,10 @@ TEST_F(RtcpParserTest, InjectReceiverReportWithReceiverLogVerificationMulti) { RtcpReceiverEventLogMessage event_log; event_log.type = FRAME_ACK_SENT; event_log.event_timestamp = testing_clock.NowTicks(); - event_log.delay_delta = - base::TimeDelta::FromMilliseconds((j - 50) * kDelayDeltaMs); + event_log.delay_delta = base::Milliseconds((j - 50) * kDelayDeltaMs); frame_log.event_log_messages_.push_back(event_log); receiver_log.push_back(frame_log); - testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); + testing_clock.Advance(base::Milliseconds(kTimeDelayMs)); } TestRtcpPacketBuilder p; @@ -524,7 +522,7 @@ TEST(RtcpUtilityTest, NtpAndTime) { base::TimeTicks out_1 = ConvertNtpToTimeTicks(ntp_seconds_1, ntp_fraction_1); EXPECT_EQ(input_time, out_1); // Verify inverse. - base::TimeDelta time_delta = base::TimeDelta::FromMilliseconds(1000); + base::TimeDelta time_delta = base::Milliseconds(1000); input_time += time_delta; uint32_t ntp_seconds_2 = 0; @@ -539,7 +537,7 @@ TEST(RtcpUtilityTest, NtpAndTime) { EXPECT_EQ((ntp_seconds_2 - ntp_seconds_1), UINT32_C(1)); EXPECT_NEAR(ntp_fraction_2, ntp_fraction_1, 1); - time_delta = base::TimeDelta::FromMilliseconds(500); + time_delta = base::Milliseconds(500); input_time += time_delta; uint32_t ntp_seconds_3 = 0; diff --git a/chromium/media/cast/net/rtcp/sender_rtcp_session.cc b/chromium/media/cast/net/rtcp/sender_rtcp_session.cc index dba167915ed..3d974afc725 100644 --- a/chromium/media/cast/net/rtcp/sender_rtcp_session.cc +++ b/chromium/media/cast/net/rtcp/sender_rtcp_session.cc @@ -39,7 +39,7 @@ base::TimeDelta ConvertFromNtpDiff(uint32_t ntp_delay) { delay_us >>= 16; delay_us += ((ntp_delay & 0xffff0000) >> 16) * base::Time::kMicrosecondsPerSecond; - return base::TimeDelta::FromMicroseconds(delay_us); + return base::Microseconds(delay_us); } // A receiver frame event is identified by frame RTP timestamp, event timestamp @@ -159,7 +159,7 @@ void SenderRtcpSession::OnReceivedDelaySinceLastReport( // such a level of precision cannot be measured with our approach; and 1 ms is // good enough to represent "under 1 ms" for our use cases. current_round_trip_time_ = - std::max(current_round_trip_time_, base::TimeDelta::FromMilliseconds(1)); + std::max(current_round_trip_time_, base::Milliseconds(1)); rtcp_observer_->OnReceivedRtt(current_round_trip_time_); } @@ -178,7 +178,7 @@ void SenderRtcpSession::SaveLastSentNtpTime(const base::TimeTicks& now, last_reports_sent_queue_.push(std::make_pair(last_report, now)); const base::TimeTicks timeout = - now - base::TimeDelta::FromMilliseconds(kStatsHistoryWindowMs); + now - base::Milliseconds(kStatsHistoryWindowMs); // Cleanup old statistics older than |timeout|. while (!last_reports_sent_queue_.empty()) { diff --git a/chromium/media/cast/net/rtcp/sender_rtcp_session.h b/chromium/media/cast/net/rtcp/sender_rtcp_session.h index 08ec817a4f5..0ff85b79eaa 100644 --- a/chromium/media/cast/net/rtcp/sender_rtcp_session.h +++ b/chromium/media/cast/net/rtcp/sender_rtcp_session.h @@ -48,6 +48,9 @@ class SenderRtcpSession : public RtcpSession { uint32_t local_ssrc, uint32_t remote_ssrc); + SenderRtcpSession(const SenderRtcpSession&) = delete; + SenderRtcpSession& operator=(const SenderRtcpSession&) = delete; + ~SenderRtcpSession() override; // If greater than zero, this is the last measured network round trip time. @@ -128,8 +131,6 @@ class SenderRtcpSession : public RtcpSession { // when last report is received from RTP receiver. RtcpSendTimeMap last_reports_sent_map_; RtcpSendTimeQueue last_reports_sent_queue_; - - DISALLOW_COPY_AND_ASSIGN(SenderRtcpSession); }; } // namespace cast diff --git a/chromium/media/cast/net/rtp/packet_storage.h b/chromium/media/cast/net/rtp/packet_storage.h index 3766c42fa99..b78ec61b05a 100644 --- a/chromium/media/cast/net/rtp/packet_storage.h +++ b/chromium/media/cast/net/rtp/packet_storage.h @@ -18,6 +18,10 @@ namespace cast { class PacketStorage { public: PacketStorage(); + + PacketStorage(const PacketStorage&) = delete; + PacketStorage& operator=(const PacketStorage&) = delete; + virtual ~PacketStorage(); // Store all of the packets for a frame. @@ -39,8 +43,6 @@ class PacketStorage { // The number of frames whose packets have been released, but the entry in the // |frames_| queue has not yet been popped. size_t zombie_count_; - - DISALLOW_COPY_AND_ASSIGN(PacketStorage); }; } // namespace cast diff --git a/chromium/media/cast/net/rtp/rtp_packetizer_unittest.cc b/chromium/media/cast/net/rtp/rtp_packetizer_unittest.cc index 090f13723cd..c0af7dfebae 100644 --- a/chromium/media/cast/net/rtp/rtp_packetizer_unittest.cc +++ b/chromium/media/cast/net/rtp/rtp_packetizer_unittest.cc @@ -134,7 +134,7 @@ class RtpPacketizerTest : public ::testing::Test { void RunTasks(int during_ms) { for (int i = 0; i < during_ms; ++i) { // Call process the timers every 1 ms. - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(1)); + testing_clock_.Advance(base::Milliseconds(1)); task_runner_->RunTasks(); } } @@ -157,7 +157,7 @@ TEST_F(RtpPacketizerTest, SendStandardPackets) { transport_->set_expected_number_of_packets(expected_num_of_packets); transport_->set_rtp_timestamp(video_frame_.rtp_timestamp); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kTimestampMs)); + testing_clock_.Advance(base::Milliseconds(kTimestampMs)); video_frame_.reference_time = testing_clock_.NowTicks(); rtp_packetizer_->SendFrameAsPackets(video_frame_); RunTasks(33 + 1); @@ -169,7 +169,7 @@ TEST_F(RtpPacketizerTest, SendPacketsWithAdaptivePlayoutExtension) { transport_->set_expected_number_of_packets(expected_num_of_packets); transport_->set_rtp_timestamp(video_frame_.rtp_timestamp); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kTimestampMs)); + testing_clock_.Advance(base::Milliseconds(kTimestampMs)); video_frame_.reference_time = testing_clock_.NowTicks(); video_frame_.new_playout_delay_ms = 500; rtp_packetizer_->SendFrameAsPackets(video_frame_); @@ -185,7 +185,7 @@ TEST_F(RtpPacketizerTest, Stats) { transport_->set_expected_number_of_packets(expected_num_of_packets); transport_->set_rtp_timestamp(video_frame_.rtp_timestamp); - testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kTimestampMs)); + testing_clock_.Advance(base::Milliseconds(kTimestampMs)); video_frame_.reference_time = testing_clock_.NowTicks(); rtp_packetizer_->SendFrameAsPackets(video_frame_); RunTasks(33 + 1); diff --git a/chromium/media/cast/net/rtp/rtp_parser.h b/chromium/media/cast/net/rtp/rtp_parser.h index 860437c4e20..b87e2aca178 100644 --- a/chromium/media/cast/net/rtp/rtp_parser.h +++ b/chromium/media/cast/net/rtp/rtp_parser.h @@ -22,6 +22,9 @@ class RtpParser { public: RtpParser(uint32_t expected_sender_ssrc, uint8_t expected_payload_type); + RtpParser(const RtpParser&) = delete; + RtpParser& operator=(const RtpParser&) = delete; + virtual ~RtpParser(); // Parses the |packet|, expecting an RTP header along with a Cast header at @@ -47,8 +50,6 @@ class RtpParser { // re-expanded into full-form. RtpTimeTicks last_parsed_rtp_timestamp_; FrameId last_parsed_frame_id_; - - DISALLOW_COPY_AND_ASSIGN(RtpParser); }; } // namespace cast diff --git a/chromium/media/cast/net/rtp/rtp_sender.cc b/chromium/media/cast/net/rtp/rtp_sender.cc index 181890a553f..23b11269d01 100644 --- a/chromium/media/cast/net/rtp/rtp_sender.cc +++ b/chromium/media/cast/net/rtp/rtp_sender.cc @@ -79,8 +79,9 @@ void RtpSender::ResendPackets( if (!stored_packets) continue; - for (auto it = stored_packets->begin(); it != stored_packets->end(); ++it) { - const PacketKey& packet_key = it->first; + for (auto packet_it = stored_packets->begin(); + packet_it != stored_packets->end(); ++packet_it) { + const PacketKey& packet_key = packet_it->first; const uint16_t packet_id = packet_key.packet_id; // Should we resend the packet? @@ -94,7 +95,7 @@ void RtpSender::ResendPackets( // If we were asked to resend the last packet, check if it's the // last packet. - if (!resend && resend_last && (it + 1) == stored_packets->end()) { + if (!resend && resend_last && (packet_it + 1) == stored_packets->end()) { resend = true; } @@ -102,11 +103,11 @@ void RtpSender::ResendPackets( // Resend packet to the network. VLOG(3) << "Resend " << frame_id << ":" << packet_id; // Set a unique incremental sequence number for every packet. - PacketRef packet_copy = FastCopyPacket(it->second); + PacketRef packet_copy = FastCopyPacket(packet_it->second); UpdateSequenceNumber(&packet_copy->data); packets_to_resend.push_back(std::make_pair(packet_key, packet_copy)); } else if (cancel_rtx_if_not_in_list) { - transport_->CancelSendingPacket(it->first); + transport_->CancelSendingPacket(packet_it->first); } } transport_->ResendPackets(packets_to_resend, dedup_info); diff --git a/chromium/media/cast/net/rtp/rtp_sender.h b/chromium/media/cast/net/rtp/rtp_sender.h index fc9ce99f05f..02a60186325 100644 --- a/chromium/media/cast/net/rtp/rtp_sender.h +++ b/chromium/media/cast/net/rtp/rtp_sender.h @@ -37,6 +37,9 @@ class RtpSender { const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner, PacedSender* const transport); + RtpSender(const RtpSender&) = delete; + RtpSender& operator=(const RtpSender&) = delete; + ~RtpSender(); // This must be called before sending any frames. Returns false if @@ -78,8 +81,6 @@ class RtpSender { // NOTE: Weak pointers must be invalidated before all other member variables. base::WeakPtrFactory<RtpSender> weak_factory_{this}; - - DISALLOW_COPY_AND_ASSIGN(RtpSender); }; } // namespace cast diff --git a/chromium/media/cast/net/udp_packet_pipe.h b/chromium/media/cast/net/udp_packet_pipe.h index b05273675df..4970785a365 100644 --- a/chromium/media/cast/net/udp_packet_pipe.h +++ b/chromium/media/cast/net/udp_packet_pipe.h @@ -18,6 +18,9 @@ class UdpPacketPipeReader { explicit UdpPacketPipeReader( mojo::ScopedDataPipeConsumerHandle consumer_handle); + UdpPacketPipeReader(const UdpPacketPipeReader&) = delete; + UdpPacketPipeReader& operator=(const UdpPacketPipeReader&) = delete; + ~UdpPacketPipeReader(); using ReadCB = base::OnceCallback<void(std::unique_ptr<Packet>)>; @@ -37,8 +40,6 @@ class UdpPacketPipeReader { MojoDataPipeReader data_pipe_reader_; uint16_t current_packet_size_; - - DISALLOW_COPY_AND_ASSIGN(UdpPacketPipeReader); }; // Writes UDP packets into the data mojo pipe. The size of each packet is @@ -48,6 +49,9 @@ class UdpPacketPipeWriter { explicit UdpPacketPipeWriter( mojo::ScopedDataPipeProducerHandle producer_handle); + UdpPacketPipeWriter(const UdpPacketPipeWriter&) = delete; + UdpPacketPipeWriter& operator=(const UdpPacketPipeWriter&) = delete; + ~UdpPacketPipeWriter(); // Writes the |packet| into the mojo data pipe. |done_cb| will be @@ -71,8 +75,6 @@ class UdpPacketPipeWriter { MojoDataPipeWriter data_pipe_writer_; uint16_t current_packet_size_ = 0; - - DISALLOW_COPY_AND_ASSIGN(UdpPacketPipeWriter); }; } // namespace cast diff --git a/chromium/media/cast/net/udp_packet_pipe_unittest.cc b/chromium/media/cast/net/udp_packet_pipe_unittest.cc index 69ca2d17814..1201fe0fcab 100644 --- a/chromium/media/cast/net/udp_packet_pipe_unittest.cc +++ b/chromium/media/cast/net/udp_packet_pipe_unittest.cc @@ -35,6 +35,9 @@ class UdpPacketPipeTest : public ::testing::Test { reader_ = std::make_unique<UdpPacketPipeReader>(std::move(consumer_handle)); } + UdpPacketPipeTest(const UdpPacketPipeTest&) = delete; + UdpPacketPipeTest& operator=(const UdpPacketPipeTest&) = delete; + ~UdpPacketPipeTest() override = default; void OnPacketRead(std::unique_ptr<Packet> packet) { @@ -46,9 +49,6 @@ class UdpPacketPipeTest : public ::testing::Test { std::unique_ptr<UdpPacketPipeWriter> writer_; std::unique_ptr<UdpPacketPipeReader> reader_; base::circular_deque<std::unique_ptr<Packet>> packets_read_; - - private: - DISALLOW_COPY_AND_ASSIGN(UdpPacketPipeTest); }; TEST_F(UdpPacketPipeTest, Normal) { diff --git a/chromium/media/cast/net/udp_transport_impl.h b/chromium/media/cast/net/udp_transport_impl.h index 0b60a35bded..638ff7d6713 100644 --- a/chromium/media/cast/net/udp_transport_impl.h +++ b/chromium/media/cast/net/udp_transport_impl.h @@ -46,6 +46,10 @@ class UdpTransportImpl final : public PacketTransport, public UdpTransport { const net::IPEndPoint& local_end_point, const net::IPEndPoint& remote_end_point, CastTransportStatusCallback status_callback); + + UdpTransportImpl(const UdpTransportImpl&) = delete; + UdpTransportImpl& operator=(const UdpTransportImpl&) = delete; + ~UdpTransportImpl() final; // PacketTransport implementations. @@ -136,8 +140,6 @@ class UdpTransportImpl final : public PacketTransport, public UdpTransport { // NOTE: Weak pointers must be invalidated before all other member variables. base::WeakPtrFactory<UdpTransportImpl> weak_factory_{this}; - - DISALLOW_COPY_AND_ASSIGN(UdpTransportImpl); }; } // namespace cast diff --git a/chromium/media/cast/net/udp_transport_unittest.cc b/chromium/media/cast/net/udp_transport_unittest.cc index 9e301406405..8711b53fd84 100644 --- a/chromium/media/cast/net/udp_transport_unittest.cc +++ b/chromium/media/cast/net/udp_transport_unittest.cc @@ -87,6 +87,9 @@ class UdpTransportImplTest : public ::testing::Test { recv_transport_->SetSendBufferSize(65536); } + UdpTransportImplTest(const UdpTransportImplTest&) = delete; + UdpTransportImplTest& operator=(const UdpTransportImplTest&) = delete; + ~UdpTransportImplTest() override = default; protected: @@ -96,9 +99,6 @@ class UdpTransportImplTest : public ::testing::Test { // A receiver side transport to receiver/send packets from/to sender. std::unique_ptr<UdpTransportImpl> recv_transport_; - - private: - DISALLOW_COPY_AND_ASSIGN(UdpTransportImplTest); }; // Test the sending/receiving functions as a PacketSender. |