diff --git a/audio/channel_send.cc b/audio/channel_send.cc
index 7d40048967..4a2700177b 100644
--- a/audio/channel_send.cc
+++ b/audio/channel_send.cc
@@ -413,8 +413,6 @@ ChannelSend::ChannelSend(
   configuration.report_block_data_observer = this;
   configuration.network_link_rtcp_observer =
       transport_controller->GetRtcpObserver();
-  configuration.transport_feedback_callback =
-      transport_controller->transport_feedback_observer();
   configuration.clock = (clock ? clock : Clock::GetRealTimeClock());
   configuration.audio = true;
   configuration.outgoing_transport = rtp_transport;
diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc
index 7e0580d1e2..a10d75d2e0 100644
--- a/call/rtp_transport_controller_send.cc
+++ b/call/rtp_transport_controller_send.cc
@@ -9,6 +9,7 @@
  */
 #include "call/rtp_transport_controller_send.h"
 
+#include <cstdint>
 #include <memory>
 #include <utility>
 #include <vector>
@@ -26,7 +27,9 @@
 #include "call/rtp_video_sender.h"
 #include "logging/rtc_event_log/events/rtc_event_remote_estimate.h"
 #include "logging/rtc_event_log/events/rtc_event_route_change.h"
+#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
+#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/rate_limiter.h"
@@ -112,6 +115,11 @@ RtpTransportControllerSend::RtpTransportControllerSend(
     // Default burst interval overriden by config.
     pacer_.SetSendBurstInterval(*config.pacer_burst_interval);
   }
+  packet_router_.RegisterNotifyBweCallback(
+      [this](const RtpPacketToSend& packet,
+             const PacedPacketInfo& pacing_info) {
+        return NotifyBweOfPacedSentPacket(packet, pacing_info);
+      });
 }
 
 RtpTransportControllerSend::~RtpTransportControllerSend() {
@@ -224,11 +232,6 @@ RtpTransportControllerSend::network_state_estimate_observer() {
   return this;
 }
 
-TransportFeedbackObserver*
-RtpTransportControllerSend::transport_feedback_observer() {
-  return this;
-}
-
 RtpPacketSender* RtpTransportControllerSend::packet_sender() {
   return &pacer_;
 }
@@ -570,9 +573,20 @@ void RtpTransportControllerSend::OnRttUpdate(Timestamp receive_time,
     PostUpdates(controller_->OnRoundTripTimeUpdate(report));
 }
 
-void RtpTransportControllerSend::OnAddPacket(
-    const RtpPacketSendInfo& packet_info) {
+void RtpTransportControllerSend::NotifyBweOfPacedSentPacket(
+    const RtpPacketToSend& packet,
+    const PacedPacketInfo& pacing_info) {
   RTC_DCHECK_RUN_ON(&sequence_checker_);
+
+  if (!packet.transport_sequence_number()) {
+    return;
+  }
+  if (!packet.packet_type()) {
+    RTC_DCHECK_NOTREACHED() << "Unknown packet type";
+    return;
+  }
+
+  RtpPacketSendInfo packet_info = RtpPacketSendInfo::From(packet, pacing_info);
   Timestamp creation_time =
       Timestamp::Millis(env_.clock().TimeInMilliseconds());
   feedback_demuxer_.AddPacket(packet_info);
diff --git a/call/rtp_transport_controller_send.h b/call/rtp_transport_controller_send.h
index 3d4db3c815..68f14b4987 100644
--- a/call/rtp_transport_controller_send.h
+++ b/call/rtp_transport_controller_send.h
@@ -12,6 +12,7 @@
 #define CALL_RTP_TRANSPORT_CONTROLLER_SEND_H_
 
 #include <atomic>
+#include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
@@ -46,7 +47,6 @@ class FrameEncryptorInterface;
 class RtpTransportControllerSend final
     : public RtpTransportControllerSendInterface,
       public NetworkLinkRtcpObserver,
-      public TransportFeedbackObserver,
       public NetworkStateEstimateObserver {
  public:
   explicit RtpTransportControllerSend(const RtpTransportConfig& config);
@@ -77,7 +77,6 @@ class RtpTransportControllerSend final
   PacketRouter* packet_router() override;
 
   NetworkStateEstimateObserver* network_state_estimate_observer() override;
-  TransportFeedbackObserver* transport_feedback_observer() override;
   RtpPacketSender* packet_sender() override;
 
   void SetAllocatedSendBitrateLimits(BitrateAllocationLimits limits) override;
@@ -118,9 +117,6 @@ class RtpTransportControllerSend final
   void OnTransportFeedback(Timestamp receive_time,
                            const rtcp::TransportFeedback& feedback) override;
 
-  // Implements TransportFeedbackObserver interface
-  void OnAddPacket(const RtpPacketSendInfo& packet_info) override;
-
   // Implements NetworkStateEstimateObserver interface
   void OnRemoteNetworkEstimate(NetworkStateEstimate estimate) override;
 
@@ -143,6 +139,10 @@ class RtpTransportControllerSend final
   void UpdateCongestedState() RTC_RUN_ON(sequence_checker_);
   absl::optional<bool> GetCongestedStateUpdate() const
       RTC_RUN_ON(sequence_checker_);
+
+  // Called by packet router just before packet is sent to the RTP modules.
+  void NotifyBweOfPacedSentPacket(const RtpPacketToSend& packet,
+                                  const PacedPacketInfo& pacing_info);
   void ProcessSentPacket(const rtc::SentPacket& sent_packet)
       RTC_RUN_ON(sequence_checker_);
   void ProcessSentPacketUpdates(NetworkControlUpdate updates)
diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h
index eda5b1c5a2..3fa6df55bb 100644
--- a/call/rtp_transport_controller_send_interface.h
+++ b/call/rtp_transport_controller_send_interface.h
@@ -114,7 +114,6 @@ class RtpTransportControllerSendInterface {
   virtual void DeRegisterSendingRtpStream(RtpRtcpInterface& rtp_module) = 0;
 
   virtual NetworkStateEstimateObserver* network_state_estimate_observer() = 0;
-  virtual TransportFeedbackObserver* transport_feedback_observer() = 0;
 
   virtual RtpPacketSender* packet_sender() = 0;
 
diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index 56e6845951..47e422ebfc 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -214,8 +214,6 @@ std::vector<RtpStreamSender> CreateRtpStreamSenders(
   configuration.network_link_rtcp_observer = transport->GetRtcpObserver();
   configuration.network_state_estimate_observer =
       transport->network_state_estimate_observer();
-  configuration.transport_feedback_callback =
-      transport->transport_feedback_observer();
   configuration.rtt_stats = observers.rtcp_rtt_stats;
   configuration.rtcp_packet_type_counter_observer =
       observers.rtcp_type_observer;
diff --git a/call/test/mock_rtp_transport_controller_send.h b/call/test/mock_rtp_transport_controller_send.h
index 805027009c..fff788b6dc 100644
--- a/call/test/mock_rtp_transport_controller_send.h
+++ b/call/test/mock_rtp_transport_controller_send.h
@@ -59,10 +59,6 @@ class MockRtpTransportControllerSend
               network_state_estimate_observer,
               (),
               (override));
-  MOCK_METHOD(TransportFeedbackObserver*,
-              transport_feedback_observer,
-              (),
-              (override));
   MOCK_METHOD(RtpPacketSender*, packet_sender, (), (override));
   MOCK_METHOD(void,
               SetAllocatedSendBitrateLimits,
diff --git a/modules/pacing/BUILD.gn b/modules/pacing/BUILD.gn
index 796f19e485..a24bccd39c 100644
--- a/modules/pacing/BUILD.gn
+++ b/modules/pacing/BUILD.gn
@@ -63,6 +63,7 @@ rtc_library("pacing") {
   absl_deps = [
     "//third_party/abseil-cpp/absl/cleanup",
     "//third_party/abseil-cpp/absl/container:inlined_vector",
+    "//third_party/abseil-cpp/absl/functional:any_invocable",
     "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/strings",
     "//third_party/abseil-cpp/absl/types:optional",
diff --git a/modules/pacing/packet_router.cc b/modules/pacing/packet_router.cc
index 382ffcd090..5124e94d13 100644
--- a/modules/pacing/packet_router.cc
+++ b/modules/pacing/packet_router.cc
@@ -16,7 +16,9 @@
 #include <memory>
 #include <utility>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/types/optional.h"
+#include "api/transport/network_types.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtcp_packet.h"
 #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
@@ -27,12 +29,10 @@
 
 namespace webrtc {
 
-PacketRouter::PacketRouter() : PacketRouter(1) {}
-
-PacketRouter::PacketRouter(uint16_t start_transport_seq)
+PacketRouter::PacketRouter()
     : last_send_module_(nullptr),
       active_remb_module_(nullptr),
-      transport_seq_(start_transport_seq) {}
+      transport_seq_(1) {}
 
 PacketRouter::~PacketRouter() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
@@ -75,6 +75,13 @@ bool PacketRouter::SupportsRtxPayloadPadding() const {
   return false;
 }
 
+void PacketRouter::RegisterNotifyBweCallback(
+    absl::AnyInvocable<void(const RtpPacketToSend& packet,
+                            const PacedPacketInfo& pacing_info)> callback) {
+  RTC_DCHECK_RUN_ON(&thread_checker_);
+  notify_bwe_callback_ = std::move(callback);
+}
+
 void PacketRouter::AddSendRtpModuleToMap(RtpRtcpInterface* rtp_module,
                                          uint32_t ssrc) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
@@ -156,14 +163,6 @@ void PacketRouter::SendPacket(std::unique_ptr<RtpPacketToSend> packet,
                "sequence_number", packet->SequenceNumber(), "rtp_timestamp",
                packet->Timestamp());
 
-  // With the new pacer code path, transport sequence numbers are only set here,
-  // on the pacer thread. Therefore we don't need atomics/synchronization.
-  bool assign_transport_sequence_number =
-      packet->HasExtension<TransportSequenceNumber>();
-  if (assign_transport_sequence_number) {
-    packet->set_transport_sequence_number(transport_seq_);
-  }
-
   uint32_t ssrc = packet->Ssrc();
   auto it = send_modules_map_.find(ssrc);
   if (it == send_modules_map_.end()) {
@@ -175,18 +174,24 @@ void PacketRouter::SendPacket(std::unique_ptr<RtpPacketToSend> packet,
   }
 
   RtpRtcpInterface* rtp_module = it->second;
-  if (!rtp_module->TrySendPacket(std::move(packet), cluster_info)) {
-    RTC_LOG(LS_WARNING) << "Failed to send packet, rejected by RTP module.";
+  if (!packet || !rtp_module->CanSendPacket(*packet)) {
+    RTC_LOG(LS_WARNING) << "Failed to send packet, Not sending media";
     return;
   }
+  // TODO(bugs.webrtc.org/15368): Even if the TransportSequenceNumber extension
+  // is not negotiated, we will need the transport sequence number for BWE.
+  if (packet->HasExtension<TransportSequenceNumber>()) {
+    packet->set_transport_sequence_number(transport_seq_++);
+  }
+  rtp_module->AssignSequenceNumber(*packet);
+  if (notify_bwe_callback_) {
+    notify_bwe_callback_(*packet, cluster_info);
+  }
+
+  rtp_module->SendPacket(std::move(packet), cluster_info);
   modules_used_in_current_batch_.insert(rtp_module);
 
   // Sending succeeded.
-
-  if (assign_transport_sequence_number) {
-    ++transport_seq_;
-  }
-
   if (rtp_module->SupportsRtxPayloadPadding()) {
     // This is now the last module to send media, and has the desired
     // properties needed for payload based padding. Cache it for later use.
@@ -281,11 +286,6 @@ absl::optional<uint32_t> PacketRouter::GetRtxSsrcForMedia(uint32_t ssrc) const {
   return absl::nullopt;
 }
 
-uint16_t PacketRouter::CurrentTransportSequenceNumber() const {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
-  return transport_seq_ & 0xFFFF;
-}
-
 void PacketRouter::SendRemb(int64_t bitrate_bps, std::vector<uint32_t> ssrcs) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
 
diff --git a/modules/pacing/packet_router.h b/modules/pacing/packet_router.h
index 4c5747f7e3..ae10637117 100644
--- a/modules/pacing/packet_router.h
+++ b/modules/pacing/packet_router.h
@@ -14,6 +14,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <cstdint>
 #include <list>
 #include <memory>
 #include <set>
@@ -21,6 +22,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/functional/any_invocable.h"
 #include "api/sequence_checker.h"
 #include "api/transport/network_types.h"
 #include "modules/pacing/pacing_controller.h"
@@ -41,12 +43,17 @@ class RtpRtcpInterface;
 class PacketRouter : public PacingController::PacketSender {
  public:
   PacketRouter();
-  explicit PacketRouter(uint16_t start_transport_seq);
   ~PacketRouter() override;
 
   PacketRouter(const PacketRouter&) = delete;
   PacketRouter& operator=(const PacketRouter&) = delete;
 
+  // Callback is invoked after pacing, before a packet is forwarded to the
+  // sending rtp module.
+  void RegisterNotifyBweCallback(
+      absl::AnyInvocable<void(const RtpPacketToSend& packet,
+                              const PacedPacketInfo& pacing_info)> callback);
+
   void AddSendRtpModule(RtpRtcpInterface* rtp_module, bool remb_candidate);
   void RemoveSendRtpModule(RtpRtcpInterface* rtp_module);
 
@@ -67,8 +74,6 @@ class PacketRouter : public PacingController::PacketSender {
   absl::optional<uint32_t> GetRtxSsrcForMedia(uint32_t ssrc) const override;
   void OnBatchComplete() override;
 
-  uint16_t CurrentTransportSequenceNumber() const;
-
   // Send REMB feedback.
   void SendRemb(int64_t bitrate_bps, std::vector<uint32_t> ssrcs);
 
@@ -109,6 +114,9 @@ class PacketRouter : public PacingController::PacketSender {
       RTC_GUARDED_BY(thread_checker_);
 
   uint64_t transport_seq_ RTC_GUARDED_BY(thread_checker_);
+  absl::AnyInvocable<void(RtpPacketToSend& packet,
+                          const PacedPacketInfo& pacing_info)>
+      notify_bwe_callback_ RTC_GUARDED_BY(thread_checker_) = nullptr;
 
   std::vector<std::unique_ptr<RtpPacketToSend>> pending_fec_packets_
       RTC_GUARDED_BY(thread_checker_);
diff --git a/modules/pacing/packet_router_unittest.cc b/modules/pacing/packet_router_unittest.cc
index 434cdccafa..fdd45ccbd8 100644
--- a/modules/pacing/packet_router_unittest.cc
+++ b/modules/pacing/packet_router_unittest.cc
@@ -19,6 +19,7 @@
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/fake_clock.h"
 #include "test/gmock.h"
@@ -39,7 +40,9 @@ using ::testing::AtLeast;
 using ::testing::ElementsAreArray;
 using ::testing::Field;
 using ::testing::Gt;
+using ::testing::InSequence;
 using ::testing::Le;
+using ::testing::MockFunction;
 using ::testing::NiceMock;
 using ::testing::Pointee;
 using ::testing::Property;
@@ -219,29 +222,38 @@ TEST_F(PacketRouterTest, PadsOnLastActiveMediaStream) {
   EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1));
   EXPECT_CALL(rtp_1, SupportsPadding).WillRepeatedly(Return(true));
   EXPECT_CALL(rtp_1, SupportsRtxPayloadPadding).WillRepeatedly(Return(true));
-  EXPECT_CALL(rtp_1, TrySendPacket).WillRepeatedly(Return(false));
-  EXPECT_CALL(rtp_1, TrySendPacket(
-                         Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc1)), _))
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(rtp_1, CanSendPacket)
+      .WillRepeatedly([&](const RtpPacketToSend& packet) {
+        if (packet.Ssrc() == kSsrc1) {
+          return true;
+        }
+        return false;
+      });
 
   NiceMock<MockRtpRtcpInterface> rtp_2;
   EXPECT_CALL(rtp_2, SSRC()).WillRepeatedly(Return(kSsrc2));
   EXPECT_CALL(rtp_2, SupportsPadding).WillRepeatedly(Return(true));
   EXPECT_CALL(rtp_2, SupportsRtxPayloadPadding).WillRepeatedly(Return(true));
-  EXPECT_CALL(rtp_2, TrySendPacket).WillRepeatedly(Return(false));
-  EXPECT_CALL(rtp_2, TrySendPacket(
-                         Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc2)), _))
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(rtp_2, CanSendPacket)
+      .WillRepeatedly([&](const RtpPacketToSend& packet) {
+        if (packet.Ssrc() == kSsrc2) {
+          return true;
+        }
+        return false;
+      });
 
   // Third module is sending media, but does not support rtx.
   NiceMock<MockRtpRtcpInterface> rtp_3;
   EXPECT_CALL(rtp_3, SSRC()).WillRepeatedly(Return(kSsrc3));
   EXPECT_CALL(rtp_3, SupportsPadding).WillRepeatedly(Return(true));
   EXPECT_CALL(rtp_3, SupportsRtxPayloadPadding).WillRepeatedly(Return(false));
-  EXPECT_CALL(rtp_3, TrySendPacket).WillRepeatedly(Return(false));
-  EXPECT_CALL(rtp_3, TrySendPacket(
-                         Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc3)), _))
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(rtp_3, CanSendPacket)
+      .WillRepeatedly([&](const RtpPacketToSend& packet) {
+        if (packet.Ssrc() == kSsrc3) {
+          return true;
+        }
+        return false;
+      });
 
   packet_router_.AddSendRtpModule(&rtp_1, false);
   packet_router_.AddSendRtpModule(&rtp_2, false);
@@ -307,25 +319,60 @@ TEST_F(PacketRouterTest, PadsOnLastActiveMediaStream) {
   }
 }
 
+TEST_F(PacketRouterTest, AllocatesRtpSequenceNumbersIfPacketCanBeSent) {
+  const uint16_t kSsrc1 = 1234;
+  PacketRouter packet_router;
+  NiceMock<MockRtpRtcpInterface> rtp;
+  ON_CALL(rtp, SSRC()).WillByDefault(Return(kSsrc1));
+
+  InSequence s;
+  EXPECT_CALL(rtp, CanSendPacket).WillRepeatedly(Return(true));
+  EXPECT_CALL(rtp, AssignSequenceNumber);
+  packet_router.AddSendRtpModule(&rtp, false);
+  packet_router.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo());
+
+  packet_router.OnBatchComplete();
+  packet_router.RemoveSendRtpModule(&rtp);
+}
+
+TEST_F(PacketRouterTest, DoNotAllocatesRtpSequenceNumbersIfPacketCanNotBeSent) {
+  const uint16_t kSsrc1 = 1234;
+  PacketRouter packet_router;
+  NiceMock<MockRtpRtcpInterface> rtp;
+  ON_CALL(rtp, SSRC()).WillByDefault(Return(kSsrc1));
+
+  EXPECT_CALL(rtp, CanSendPacket).WillRepeatedly(Return(false));
+  EXPECT_CALL(rtp, AssignSequenceNumber).Times(0);
+  packet_router.AddSendRtpModule(&rtp, false);
+  packet_router.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo());
+
+  packet_router.OnBatchComplete();
+  packet_router.RemoveSendRtpModule(&rtp);
+}
+
 TEST_F(PacketRouterTest, AllocatesTransportSequenceNumbers) {
-  const uint16_t kStartSeq = 0xFFF0;
-  const size_t kNumPackets = 32;
   const uint16_t kSsrc1 = 1234;
 
-  PacketRouter packet_router(kStartSeq - 1);
+  PacketRouter packet_router;
+  testing::MockFunction<void(const RtpPacketToSend& packet,
+                             const PacedPacketInfo& pacing_info)>
+      notify_bwe_callback;
   NiceMock<MockRtpRtcpInterface> rtp_1;
+  packet_router.RegisterNotifyBweCallback(notify_bwe_callback.AsStdFunction());
+
   EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1));
-  EXPECT_CALL(rtp_1, TrySendPacket).WillRepeatedly(Return(true));
+  EXPECT_CALL(rtp_1, CanSendPacket).WillRepeatedly(Return(true));
+
   packet_router.AddSendRtpModule(&rtp_1, false);
 
-  for (size_t i = 0; i < kNumPackets; ++i) {
-    auto packet = BuildRtpPacket(kSsrc1);
-    EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
-    packet_router.SendPacket(std::move(packet), PacedPacketInfo());
-    uint32_t expected_unwrapped_seq = static_cast<uint32_t>(kStartSeq) + i;
-    EXPECT_EQ(static_cast<uint16_t>(expected_unwrapped_seq & 0xFFFF),
-              packet_router.CurrentTransportSequenceNumber());
-  }
+  auto packet = BuildRtpPacket(kSsrc1);
+  EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
+  EXPECT_CALL(notify_bwe_callback, Call)
+      .WillOnce([](const RtpPacketToSend& packet,
+                   const PacedPacketInfo& pacing_info) {
+        EXPECT_EQ(packet.transport_sequence_number(), 1);
+      });
+  packet_router.SendPacket(std::move(packet), PacedPacketInfo());
 
   packet_router.OnBatchComplete();
   packet_router.RemoveSendRtpModule(&rtp_1);
@@ -358,6 +405,7 @@ TEST_F(PacketRouterTest, SendPacketWithoutTransportSequenceNumbers) {
   NiceMock<MockRtpRtcpInterface> rtp_1;
   ON_CALL(rtp_1, SendingMedia).WillByDefault(Return(true));
   ON_CALL(rtp_1, SSRC).WillByDefault(Return(kSsrc1));
+  ON_CALL(rtp_1, CanSendPacket).WillByDefault(Return(true));
   packet_router_.AddSendRtpModule(&rtp_1, false);
 
   // Send a packet without TransportSequenceNumber extension registered,
@@ -367,58 +415,18 @@ TEST_F(PacketRouterTest, SendPacketWithoutTransportSequenceNumbers) {
   packet->SetSsrc(kSsrc1);
   EXPECT_CALL(
       rtp_1,
-      TrySendPacket(
-          Pointee(Property(
-              &RtpPacketToSend::HasExtension<TransportSequenceNumber>, false)),
-          _))
-      .WillOnce(Return(true));
+      SendPacket(
+          AllOf(Pointee(Property(
+                    &RtpPacketToSend::HasExtension<TransportSequenceNumber>,
+                    false)),
+                Pointee(Property(&RtpPacketToSend::transport_sequence_number,
+                                 absl::nullopt))),
+          _));
   packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
   packet_router_.OnBatchComplete();
   packet_router_.RemoveSendRtpModule(&rtp_1);
 }
 
-TEST_F(PacketRouterTest, SendPacketAssignsTransportSequenceNumbers) {
-  NiceMock<MockRtpRtcpInterface> rtp_1;
-  NiceMock<MockRtpRtcpInterface> rtp_2;
-
-  const uint16_t kSsrc1 = 1234;
-  const uint16_t kSsrc2 = 2345;
-
-  ON_CALL(rtp_1, SSRC).WillByDefault(Return(kSsrc1));
-  ON_CALL(rtp_2, SSRC).WillByDefault(Return(kSsrc2));
-
-  packet_router_.AddSendRtpModule(&rtp_1, false);
-  packet_router_.AddSendRtpModule(&rtp_2, false);
-
-  auto packet = BuildRtpPacket(kSsrc1);
-  EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
-  EXPECT_CALL(rtp_1, TrySendPacket)
-      .WillOnce([&](std::unique_ptr<RtpPacketToSend> packet,
-                    const PacedPacketInfo& pacing_info) {
-        // Transport sequence numbers start at 1 per default, for historical
-        // reasons.
-        EXPECT_EQ(packet->transport_sequence_number(), 1);
-        return true;
-      });
-  packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
-
-  packet = BuildRtpPacket(kSsrc2);
-  EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
-
-  EXPECT_CALL(rtp_2, TrySendPacket)
-
-      .WillOnce([&](std::unique_ptr<RtpPacketToSend> packet,
-                    const PacedPacketInfo& pacing_info) {
-        EXPECT_EQ(packet->transport_sequence_number(), 2);
-        return true;
-      });
-  packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
-
-  packet_router_.OnBatchComplete();
-  packet_router_.RemoveSendRtpModule(&rtp_1);
-  packet_router_.RemoveSendRtpModule(&rtp_2);
-}
-
 TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) {
   NiceMock<MockRtpRtcpInterface> rtp;
   constexpr uint32_t kSsrc = 1234;
@@ -432,14 +440,9 @@ TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) {
   // Return failure status code to make sure sequence number is not incremented.
   auto packet = BuildRtpPacket(kSsrc);
   EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
-  EXPECT_CALL(rtp, TrySendPacket)
-
-      .WillOnce([&](std::unique_ptr<RtpPacketToSend> packet,
-                    const PacedPacketInfo& pacing_info) {
-        EXPECT_EQ(packet->transport_sequence_number(),
-                  kStartTransportSequenceNumber);
-        return false;
-      });
+  EXPECT_CALL(rtp, CanSendPacket).WillOnce([&](const RtpPacketToSend& packet) {
+    return false;
+  });
   packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
 
   // Send another packet, verify transport sequence number is still at the
@@ -447,12 +450,12 @@ TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) {
   packet = BuildRtpPacket(kSsrc);
   EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
 
-  EXPECT_CALL(rtp, TrySendPacket)
+  EXPECT_CALL(rtp, CanSendPacket).WillOnce(Return(true));
+  EXPECT_CALL(rtp, SendPacket)
       .WillOnce([&](std::unique_ptr<RtpPacketToSend> packet,
                     const PacedPacketInfo& pacing_info) {
         EXPECT_EQ(packet->transport_sequence_number(),
                   kStartTransportSequenceNumber);
-        return false;
       });
   packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
 
@@ -531,7 +534,7 @@ TEST_F(PacketRouterTest, RoutesBatchCompleteToActiveModules) {
   ON_CALL(rtp_2, SSRC).WillByDefault(Return(kSsrc2));
   packet_router_.AddSendRtpModule(&rtp_1, false);
   packet_router_.AddSendRtpModule(&rtp_2, false);
-  EXPECT_CALL(rtp_1, TrySendPacket).WillOnce(Return(true));
+  EXPECT_CALL(rtp_1, CanSendPacket).WillOnce(Return(true));
   packet_router_.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo());
   EXPECT_CALL(rtp_1, OnBatchComplete);
   EXPECT_CALL(rtp_2, OnBatchComplete).Times(0);