Distinguish between missing packet and send failure.

This CL introduces three-value enum, in order to be able to distinguish between send success, send failure, and invalid states such as missing packet or invalid ssrc. The behavior is unchanged in this CL, a follow-up will change the pacer to not consume media budget on invalid states. Bug: webrtc:8052,webrtc:8975 Change-Id: I1c9e2226f995356daa538d3d3cf44945f35e0133 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/135165 Commit-Queue: Erik Språng <sprang@webrtc.org> Reviewed-by: Sebastian Jansson <srte@webrtc.org> Reviewed-by: Danil Chapovalov <danilchap@webrtc.org> Cr-Commit-Position: refs/heads/master@{#27923}
2019-05-10 08:29:01 -07:00
parent d7c7d0ed88
commit d28796209b
17 changed files with 215 additions and 171 deletions
--- a/modules/pacing/paced_sender.cc
+++ b/modules/pacing/paced_sender.cc
@ -371,11 +371,14 @@ void PacedSender::Process() {
      break;

    critsect_.Leave();
-    bool success = packet_sender_->TimeToSendPacket(
+    RtpPacketSendResult success = packet_sender_->TimeToSendPacket(
        packet->ssrc, packet->sequence_number, packet->capture_time_ms,
        packet->retransmission, pacing_info);
    critsect_.Enter();
-    if (success) {
+    if (success == RtpPacketSendResult::kSuccess ||
+        success == RtpPacketSendResult::kPacketNotFound) {
+      // Packet sent or invalid packet, remove it from queue.
+      // TODO(webrtc:8052): Don't consume media budget on kInvalid.
      bytes_sent += packet->bytes;
      // Send succeeded, remove it from the queue.
      OnPacketSent(packet);
@ -443,10 +446,6 @@ void PacedSender::OnPacketSent(const RoundRobinPacketQueue::Packet* packet) {
  bool audio_packet = packet->priority == kHighPriority;
  if (!audio_packet || account_for_audio_) {
    // Update media bytes sent.
-    // TODO(eladalon): TimeToSendPacket() can also return |true| in some
-    // situations where nothing actually ended up being sent to the network,
-    // and we probably don't want to update the budget in such cases.
-    // https://bugs.chromium.org/p/webrtc/issues/detail?id=8052
    UpdateBudgetWithBytesSent(packet->bytes);
    last_send_time_us_ = clock_->TimeInMicroseconds();
  }
--- a/modules/pacing/paced_sender.h
+++ b/modules/pacing/paced_sender.h
@ -44,11 +44,12 @@ class PacedSender : public Pacer {
    // module again.
    // Called when it's time to send a queued packet.
    // Returns false if packet cannot be sent.
-    virtual bool TimeToSendPacket(uint32_t ssrc,
-                                  uint16_t sequence_number,
-                                  int64_t capture_time_ms,
-                                  bool retransmission,
-                                  const PacedPacketInfo& cluster_info) = 0;
+    virtual RtpPacketSendResult TimeToSendPacket(
+        uint32_t ssrc,
+        uint16_t sequence_number,
+        int64_t capture_time_ms,
+        bool retransmission,
+        const PacedPacketInfo& cluster_info) = 0;
    // Called when it's a good time to send a padding data.
    // Returns the number of bytes sent.
    virtual size_t TimeToSendPadding(size_t bytes,
--- a/modules/pacing/paced_sender_unittest.cc
+++ b/modules/pacing/paced_sender_unittest.cc
@ -43,11 +43,11 @@ static const int kTargetBitrateBps = 800000;
 class MockPacedSenderCallback : public PacedSender::PacketSender {
 public:
  MOCK_METHOD5(TimeToSendPacket,
-               bool(uint32_t ssrc,
-                    uint16_t sequence_number,
-                    int64_t capture_time_ms,
-                    bool retransmission,
-                    const PacedPacketInfo& pacing_info));
+               RtpPacketSendResult(uint32_t ssrc,
+                                   uint16_t sequence_number,
+                                   int64_t capture_time_ms,
+                                   bool retransmission,
+                                   const PacedPacketInfo& pacing_info));
  MOCK_METHOD2(TimeToSendPadding,
               size_t(size_t bytes, const PacedPacketInfo& pacing_info));
 };
@ -56,12 +56,13 @@ class PacedSenderPadding : public PacedSender::PacketSender {
 public:
  PacedSenderPadding() : padding_sent_(0) {}

-  bool TimeToSendPacket(uint32_t ssrc,
-                        uint16_t sequence_number,
-                        int64_t capture_time_ms,
-                        bool retransmission,
-                        const PacedPacketInfo& pacing_info) override {
-    return true;
+  RtpPacketSendResult TimeToSendPacket(
+      uint32_t ssrc,
+      uint16_t sequence_number,
+      int64_t capture_time_ms,
+      bool retransmission,
+      const PacedPacketInfo& pacing_info) override {
+    return RtpPacketSendResult::kSuccess;
  }

  size_t TimeToSendPadding(size_t bytes,
@ -82,13 +83,14 @@ class PacedSenderProbing : public PacedSender::PacketSender {
 public:
  PacedSenderProbing() : packets_sent_(0), padding_sent_(0) {}

-  bool TimeToSendPacket(uint32_t ssrc,
-                        uint16_t sequence_number,
-                        int64_t capture_time_ms,
-                        bool retransmission,
-                        const PacedPacketInfo& pacing_info) override {
+  RtpPacketSendResult TimeToSendPacket(
+      uint32_t ssrc,
+      uint16_t sequence_number,
+      int64_t capture_time_ms,
+      bool retransmission,
+      const PacedPacketInfo& pacing_info) override {
    packets_sent_++;
-    return true;
+    return RtpPacketSendResult::kSuccess;
  }

  size_t TimeToSendPadding(size_t bytes,
@ -134,7 +136,7 @@ class PacedSenderTest : public ::testing::TestWithParam<std::string> {
    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
                                            capture_time_ms, retransmission, _))
        .Times(1)
-        .WillRepeatedly(Return(true));
+        .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
  }
  SimulatedClock clock_;
  MockPacedSenderCallback callback_;
@ -175,7 +177,8 @@ TEST_F(PacedSenderFieldTrialTest, DefaultNoPaddingInSilence) {
  pacer.SetPacingRates(kTargetBitrateBps, 0);
  // Video packet to reset last send time and provide padding data.
  InsertPacket(&pacer, &video);
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  clock_.AdvanceTimeMilliseconds(5);
  pacer.Process();
  EXPECT_CALL(callback_, TimeToSendPadding).Times(0);
@ -190,7 +193,8 @@ TEST_F(PacedSenderFieldTrialTest, PaddingInSilenceWithTrial) {
  pacer.SetPacingRates(kTargetBitrateBps, 0);
  // Video packet to reset last send time and provide padding data.
  InsertPacket(&pacer, &video);
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  clock_.AdvanceTimeMilliseconds(5);
  pacer.Process();
  EXPECT_CALL(callback_, TimeToSendPadding).WillOnce(Return(1000));
@ -207,7 +211,8 @@ TEST_F(PacedSenderFieldTrialTest, DefaultCongestionWindowAffectsAudio) {
  pacer.UpdateOutstandingData(0);
  // Video packet fills congestion window.
  InsertPacket(&pacer, &video);
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  ProcessNext(&pacer);
  // Audio packet blocked due to congestion.
  InsertPacket(&pacer, &audio);
@ -217,7 +222,8 @@ TEST_F(PacedSenderFieldTrialTest, DefaultCongestionWindowAffectsAudio) {
  // Audio packet unblocked when congestion window clear.
  ::testing::Mock::VerifyAndClearExpectations(&callback_);
  pacer.UpdateOutstandingData(0);
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  ProcessNext(&pacer);
 }

@ -230,11 +236,13 @@ TEST_F(PacedSenderFieldTrialTest, CongestionWindowDoesNotAffectAudioInTrial) {
  pacer.UpdateOutstandingData(0);
  // Video packet fills congestion window.
  InsertPacket(&pacer, &video);
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  ProcessNext(&pacer);
  // Audio not blocked due to congestion.
  InsertPacket(&pacer, &audio);
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  ProcessNext(&pacer);
 }

@ -244,7 +252,8 @@ TEST_F(PacedSenderFieldTrialTest, DefaultBudgetAffectsAudio) {
                       0);
  // Video fills budget for following process periods.
  InsertPacket(&pacer, &video);
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  ProcessNext(&pacer);
  // Audio packet blocked due to budget limit.
  EXPECT_CALL(callback_, TimeToSendPacket).Times(0);
@ -253,7 +262,8 @@ TEST_F(PacedSenderFieldTrialTest, DefaultBudgetAffectsAudio) {
  ProcessNext(&pacer);
  ::testing::Mock::VerifyAndClearExpectations(&callback_);
  // Audio packet unblocked when the budget has recovered.
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  ProcessNext(&pacer);
  ProcessNext(&pacer);
 }
@ -266,10 +276,12 @@ TEST_F(PacedSenderFieldTrialTest, BudgetDoesNotAffectAudioInTrial) {
                       0);
  // Video fills budget for following process periods.
  InsertPacket(&pacer, &video);
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  ProcessNext(&pacer);
  // Audio packet not blocked due to budget limit.
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  InsertPacket(&pacer, &audio);
  ProcessNext(&pacer);
 }
@ -322,7 +334,7 @@ TEST_F(PacedSenderTest, QueuePacket) {
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number++,
                                          queued_packet_timestamp, false, _))
      .Times(1)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
  send_bucket_->Process();
  sequence_number++;
  EXPECT_EQ(0u, send_bucket_->QueueSizePackets());
@ -371,7 +383,7 @@ TEST_F(PacedSenderTest, PaceQueuedPackets) {
    clock_.AdvanceTimeMilliseconds(5);
    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, _, false, _))
        .Times(packets_to_send_per_interval)
-        .WillRepeatedly(Return(true));
+        .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
    EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
    send_bucket_->Process();
  }
@ -571,7 +583,7 @@ TEST_F(PacedSenderTest, Priority) {
  EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false, _))
      .Times(packets_to_send_per_interval + 1)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));

  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
  clock_.AdvanceTimeMilliseconds(5);
@ -583,7 +595,7 @@ TEST_F(PacedSenderTest, Priority) {
              TimeToSendPacket(ssrc_low_priority, _,
                               capture_time_ms_low_priority, false, _))
      .Times(1)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));

  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
  clock_.AdvanceTimeMilliseconds(5);
@ -622,7 +634,7 @@ TEST_F(PacedSenderTest, RetransmissionPriority) {
  EXPECT_CALL(callback_, TimeToSendPacket(
                             ssrc, _, capture_time_ms_retransmission, true, _))
      .Times(packets_to_send_per_interval)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));

  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
  clock_.AdvanceTimeMilliseconds(5);
@ -635,7 +647,7 @@ TEST_F(PacedSenderTest, RetransmissionPriority) {
  EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, true, _)).Times(0);
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false, _))
      .Times(packets_to_send_per_interval)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));

  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
  clock_.AdvanceTimeMilliseconds(5);
@ -676,7 +688,7 @@ TEST_F(PacedSenderTest, HighPrioDoesntAffectBudget) {
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number++,
                                          capture_time_ms, false, _))
      .Times(1)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
  clock_.AdvanceTimeMilliseconds(5);
  send_bucket_->Process();
@ -736,7 +748,8 @@ TEST_F(PacedSenderTest, DoesNotAllowOveruseAfterCongestion) {
  send_bucket_->UpdateOutstandingData(0);
  // Not yet budget limited or congested, packet is sent.
  send_bucket_->InsertPacket(prio, ssrc, seq_num++, now_ms(), size, false);
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  clock_.AdvanceTimeMilliseconds(5);
  send_bucket_->Process();
  // Packet blocked due to congestion.
@ -752,7 +765,8 @@ TEST_F(PacedSenderTest, DoesNotAllowOveruseAfterCongestion) {
  send_bucket_->UpdateOutstandingData(0);
  // Congestion removed and budget has recovered, packet is sent.
  send_bucket_->InsertPacket(prio, ssrc, seq_num++, now_ms(), size, false);
-  EXPECT_CALL(callback_, TimeToSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(callback_, TimeToSendPacket)
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  clock_.AdvanceTimeMilliseconds(5);
  send_bucket_->Process();
  send_bucket_->UpdateOutstandingData(0);
@ -799,7 +813,7 @@ TEST_F(PacedSenderTest, ResumesSendingWhenCongestionEnds) {
  int ack_count = kCongestionCount / 2;
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, _, false, _))
      .Times(ack_count)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
  send_bucket_->UpdateOutstandingData(kCongestionWindow -
                                      kPacketSize * ack_count);

@ -814,7 +828,7 @@ TEST_F(PacedSenderTest, ResumesSendingWhenCongestionEnds) {
  // marked as acked.
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, _, false, _))
      .Times(unacked_packets)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
  for (int duration = 0; duration < kCongestionTimeMs; duration += 5) {
    send_bucket_->UpdateOutstandingData(0);
    clock_.AdvanceTimeMilliseconds(5);
@ -895,34 +909,34 @@ TEST_F(PacedSenderTest, Pause) {
    EXPECT_CALL(callback_,
                TimeToSendPacket(ssrc_high_priority, _, capture_time_ms, _, _))
        .Times(packets_to_send_per_interval)
-        .WillRepeatedly(Return(true));
+        .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
    EXPECT_CALL(callback_, TimeToSendPacket(ssrc_high_priority, _,
                                            second_capture_time_ms, _, _))
        .Times(packets_to_send_per_interval)
-        .WillRepeatedly(Return(true));
+        .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));

    for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
      EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, _, _))
          .Times(1)
-          .WillRepeatedly(Return(true));
+          .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
    }
    for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
      EXPECT_CALL(callback_,
                  TimeToSendPacket(ssrc, _, second_capture_time_ms, _, _))
          .Times(1)
-          .WillRepeatedly(Return(true));
+          .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
    }
    for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
      EXPECT_CALL(callback_,
                  TimeToSendPacket(ssrc_low_priority, _, capture_time_ms, _, _))
          .Times(1)
-          .WillRepeatedly(Return(true));
+          .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
    }
    for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
      EXPECT_CALL(callback_, TimeToSendPacket(ssrc_low_priority, _,
                                              second_capture_time_ms, _, _))
          .Times(1)
-          .WillRepeatedly(Return(true));
+          .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
    }
  }
  send_bucket_->Resume();
@ -961,7 +975,7 @@ TEST_F(PacedSenderTest, ResendPacket) {
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
                                          capture_time_ms, false, _))
      .Times(1)
-      .WillOnce(Return(false));
+      .WillOnce(Return(RtpPacketSendResult::kTransportUnavailable));
  clock_.AdvanceTimeMilliseconds(10000);
  send_bucket_->Process();

@ -973,11 +987,11 @@ TEST_F(PacedSenderTest, ResendPacket) {
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
                                          capture_time_ms, false, _))
      .Times(1)
-      .WillOnce(Return(true));
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
                                          capture_time_ms + 1, false, _))
      .Times(1)
-      .WillOnce(Return(false));
+      .WillOnce(Return(RtpPacketSendResult::kTransportUnavailable));
  clock_.AdvanceTimeMilliseconds(10000);
  send_bucket_->Process();

@ -989,7 +1003,7 @@ TEST_F(PacedSenderTest, ResendPacket) {
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
                                          capture_time_ms + 1, false, _))
      .Times(1)
-      .WillOnce(Return(true));
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  clock_.AdvanceTimeMilliseconds(10000);
  send_bucket_->Process();
  EXPECT_EQ(0, send_bucket_->QueueInMs());
@ -1183,7 +1197,7 @@ TEST_F(PacedSenderTest, AverageQueueTime) {
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
                                          first_capture_time, false, _))
      .Times(1)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
  send_bucket_->Process();

  EXPECT_EQ(10, send_bucket_->AverageQueueTimeMs());
@ -1192,7 +1206,7 @@ TEST_F(PacedSenderTest, AverageQueueTime) {
  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
                                          first_capture_time + 10, false, _))
      .Times(1)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
  for (int i = 0; i < 3; ++i) {
    clock_.AdvanceTimeMilliseconds(30);  // Max delta.
    send_bucket_->Process();
@ -1221,7 +1235,7 @@ TEST_F(PacedSenderTest, ProbeClusterId) {
              TimeToSendPacket(_, _, _, _,
                               Field(&PacedPacketInfo::probe_cluster_id, 0)))
      .Times(5)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
  for (int i = 0; i < 5; ++i) {
    clock_.AdvanceTimeMilliseconds(20);
    send_bucket_->Process();
@ -1232,7 +1246,7 @@ TEST_F(PacedSenderTest, ProbeClusterId) {
              TimeToSendPacket(_, _, _, _,
                               Field(&PacedPacketInfo::probe_cluster_id, 1)))
      .Times(5)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(RtpPacketSendResult::kSuccess));
  for (int i = 0; i < 5; ++i) {
    clock_.AdvanceTimeMilliseconds(20);
    send_bucket_->Process();
@ -1262,7 +1276,7 @@ TEST_F(PacedSenderTest, AvoidBusyLoopOnSendFailure) {
                             kPacketSize, false);

  EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, _))
-      .WillOnce(Return(true));
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  send_bucket_->Process();
  EXPECT_EQ(10, send_bucket_->TimeUntilNextProcess());
  clock_.AdvanceTimeMilliseconds(9);
--- a/modules/pacing/packet_router.cc
+++ b/modules/pacing/packet_router.cc
@ -99,11 +99,12 @@ void PacketRouter::RemoveReceiveRtpModule(
  rtcp_feedback_senders_.erase(it);
 }

-bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
-                                    uint16_t sequence_number,
-                                    int64_t capture_timestamp,
-                                    bool retransmission,
-                                    const PacedPacketInfo& pacing_info) {
+RtpPacketSendResult PacketRouter::TimeToSendPacket(
+    uint32_t ssrc,
+    uint16_t sequence_number,
+    int64_t capture_timestamp,
+    bool retransmission,
+    const PacedPacketInfo& pacing_info) {
  rtc::CritScope cs(&modules_crit_);
  for (auto* rtp_module : rtp_send_modules_) {
    if (!rtp_module->SendingMedia()) {
@ -121,7 +122,7 @@ bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
                                          pacing_info);
    }
  }
-  return true;
+  return RtpPacketSendResult::kPacketNotFound;
 }

 size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send,
--- a/modules/pacing/packet_router.h
+++ b/modules/pacing/packet_router.h
@ -52,11 +52,12 @@ class PacketRouter : public PacedSender::PacketSender,
  void RemoveReceiveRtpModule(RtcpFeedbackSenderInterface* rtcp_sender);

  // Implements PacedSender::Callback.
-  bool TimeToSendPacket(uint32_t ssrc,
-                        uint16_t sequence_number,
-                        int64_t capture_timestamp,
-                        bool retransmission,
-                        const PacedPacketInfo& packet_info) override;
+  RtpPacketSendResult TimeToSendPacket(
+      uint32_t ssrc,
+      uint16_t sequence_number,
+      int64_t capture_timestamp,
+      bool retransmission,
+      const PacedPacketInfo& packet_info) override;

  size_t TimeToSendPadding(size_t bytes,
                           const PacedPacketInfo& packet_info) override;
--- a/modules/pacing/packet_router_unittest.cc
+++ b/modules/pacing/packet_router_unittest.cc
@ -54,11 +54,9 @@ TEST(PacketRouterTest, Sanity_NoModuleRegistered_TimeToSendPacket) {
  constexpr bool retransmission = false;
  const PacedPacketInfo paced_info(1, kProbeMinProbes, kProbeMinBytes);

-  // TODO(eladalon): TimeToSendPacket() returning true when nothing was
-  // sent, because no modules were registered, is sub-optimal.
-  // https://bugs.chromium.org/p/webrtc/issues/detail?id=8052
-  EXPECT_TRUE(packet_router.TimeToSendPacket(ssrc, sequence_number, timestamp,
-                                             retransmission, paced_info));
+  EXPECT_EQ(RtpPacketSendResult::kPacketNotFound,
+            packet_router.TimeToSendPacket(ssrc, sequence_number, timestamp,
+                                           retransmission, paced_info));
 }

 TEST(PacketRouterTest, Sanity_NoModuleRegistered_TimeToSendPadding) {
@ -116,11 +114,12 @@ TEST(PacketRouterTest, TimeToSendPacket) {
                         kSsrc1, sequence_number, timestamp, retransmission,
                         Field(&PacedPacketInfo::probe_cluster_id, 1)))
      .Times(1)
-      .WillOnce(Return(true));
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
  EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
-  EXPECT_TRUE(packet_router.TimeToSendPacket(
-      kSsrc1, sequence_number, timestamp, retransmission,
-      PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes)));
+  EXPECT_EQ(RtpPacketSendResult::kSuccess,
+            packet_router.TimeToSendPacket(
+                kSsrc1, sequence_number, timestamp, retransmission,
+                PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes)));

  // Send on the second module by letting rtp_2 be sending, but not rtp_1.
  ++sequence_number;
@ -135,19 +134,21 @@ TEST(PacketRouterTest, TimeToSendPacket) {
                         kSsrc2, sequence_number, timestamp, retransmission,
                         Field(&PacedPacketInfo::probe_cluster_id, 2)))
      .Times(1)
-      .WillOnce(Return(true));
-  EXPECT_TRUE(packet_router.TimeToSendPacket(
-      kSsrc2, sequence_number, timestamp, retransmission,
-      PacedPacketInfo(2, kProbeMinProbes, kProbeMinBytes)));
+      .WillOnce(Return(RtpPacketSendResult::kSuccess));
+  EXPECT_EQ(RtpPacketSendResult::kSuccess,
+            packet_router.TimeToSendPacket(
+                kSsrc2, sequence_number, timestamp, retransmission,
+                PacedPacketInfo(2, kProbeMinProbes, kProbeMinBytes)));

  // No module is sending, hence no packet should be sent.
  EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false));
  EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0);
  EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false));
  EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
-  EXPECT_TRUE(packet_router.TimeToSendPacket(
-      kSsrc1, sequence_number, timestamp, retransmission,
-      PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes)));
+  EXPECT_EQ(RtpPacketSendResult::kPacketNotFound,
+            packet_router.TimeToSendPacket(
+                kSsrc1, sequence_number, timestamp, retransmission,
+                PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes)));

  // Add a packet with incorrect ssrc and test it's dropped in the router.
  EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true));
@ -156,9 +157,10 @@ TEST(PacketRouterTest, TimeToSendPacket) {
  EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2));
  EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0);
  EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
-  EXPECT_TRUE(packet_router.TimeToSendPacket(
-      kSsrc1 + kSsrc2, sequence_number, timestamp, retransmission,
-      PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes)));
+  EXPECT_EQ(RtpPacketSendResult::kPacketNotFound,
+            packet_router.TimeToSendPacket(
+                kSsrc1 + kSsrc2, sequence_number, timestamp, retransmission,
+                PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes)));

  packet_router.RemoveSendRtpModule(&rtp_1);

@ -167,10 +169,11 @@ TEST(PacketRouterTest, TimeToSendPacket) {
  EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
  EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2));
  EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
-  EXPECT_TRUE(packet_router.TimeToSendPacket(
-      kSsrc1, sequence_number, timestamp, retransmission,
-      PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes,
-                      kProbeMinBytes)));
+  EXPECT_EQ(RtpPacketSendResult::kPacketNotFound,
+            packet_router.TimeToSendPacket(
+                kSsrc1, sequence_number, timestamp, retransmission,
+                PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes,
+                                kProbeMinBytes)));

  packet_router.RemoveSendRtpModule(&rtp_2);
 }
@ -357,10 +360,11 @@ TEST(PacketRouterTest, SenderOnlyFunctionsRespectSendingMedia) {

  // Verify that TimeToSendPacket does not end up in a receiver.
  EXPECT_CALL(rtp, TimeToSendPacket(_, _, _, _, _)).Times(0);
-  EXPECT_TRUE(packet_router.TimeToSendPacket(
-      kSsrc, 1, 1, false,
-      PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes,
-                      kProbeMinBytes)));
+  EXPECT_EQ(RtpPacketSendResult::kPacketNotFound,
+            packet_router.TimeToSendPacket(
+                kSsrc, 1, 1, false,
+                PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes,
+                                kProbeMinBytes)));
  // Verify that TimeToSendPadding does not end up in a receiver.
  EXPECT_CALL(rtp, TimeToSendPadding(_, _)).Times(0);
  EXPECT_EQ(0u, packet_router.TimeToSendPadding(