Add support for transport wide sequence numbers

webrtc/modules/pacing/packet_router.cc

Index: webrtc/modules/pacing/packet_router.cc
diff --git a/webrtc/modules/pacing/packet_router.cc b/webrtc/modules/pacing/packet_router.cc
index 9e15a713174b493af7d89f7ad3971c6a1fb43029..1b124981a1c5928240339095c4b602c92d89a045 100644
--- a/webrtc/modules/pacing/packet_router.cc
+++ b/webrtc/modules/pacing/packet_router.cc
@@ -10,37 +10,39 @@
 
 #include "webrtc/modules/pacing/include/packet_router.h"
 
+#include "webrtc/base/atomicops.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
-#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 
 namespace webrtc {
 
-PacketRouter::PacketRouter()
-    : crit_(CriticalSectionWrapper::CreateCriticalSection()) {
+PacketRouter::PacketRouter() : transport_seq_(0) {
 }
 
 PacketRouter::~PacketRouter() {
+  DCHECK(rtp_modules_.empty());
 }
 
 void PacketRouter::AddRtpModule(RtpRtcp* rtp_module) {
-  CriticalSectionScoped cs(crit_.get());
+  rtc::CritScope cs(&modules_lock_);
   DCHECK(std::find(rtp_modules_.begin(), rtp_modules_.end(), rtp_module) ==
          rtp_modules_.end());
   rtp_modules_.push_back(rtp_module);
 }
 
 void PacketRouter::RemoveRtpModule(RtpRtcp* rtp_module) {
-  CriticalSectionScoped cs(crit_.get());
-  rtp_modules_.remove(rtp_module);
+  rtc::CritScope cs(&modules_lock_);
+  auto it = std::find(rtp_modules_.begin(), rtp_modules_.end(), rtp_module);
+  DCHECK(it != rtp_modules_.end());
+  rtp_modules_.erase(it);

[stefan-webrtc, 2015/07/29 12:19:52]

rtp_modules_.remove(rtp_module); as before?

[sprang_webrtc, 2015/07/29 12:27:27]

erase() will directly remove that element from the list, while remove() will
iterate over the entire list and remove all instances where value matches the
argument. Since we have already asserted that there are no duplicates in the
list this is not necessary.

 }
 
 bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
                                     uint16_t sequence_number,
                                     int64_t capture_timestamp,
                                     bool retransmission) {
-  CriticalSectionScoped cs(crit_.get());
+  rtc::CritScope cs(&modules_lock_);
   for (auto* rtp_module : rtp_modules_) {
     if (rtp_module->SendingMedia() && ssrc == rtp_module->SSRC()) {
       return rtp_module->TimeToSendPacket(ssrc, sequence_number,
@@ -50,12 +52,41 @@ bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
   return true;
 }
 
-size_t PacketRouter::TimeToSendPadding(size_t bytes) {
-  CriticalSectionScoped cs(crit_.get());
-  for (auto* rtp_module : rtp_modules_) {
-    if (rtp_module->SendingMedia())
-      return rtp_module->TimeToSendPadding(bytes);
+size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send) {
+  size_t total_bytes_sent = 0;
+  rtc::CritScope cs(&modules_lock_);
+  for (RtpRtcp* module : rtp_modules_) {
+    if (module->SendingMedia()) {
+      size_t bytes_sent =
+          module->TimeToSendPadding(bytes_to_send - total_bytes_sent);
+      total_bytes_sent += bytes_sent;
+      if (total_bytes_sent >= bytes_to_send)
+        break;
+    }
   }
-  return 0;
+  return total_bytes_sent;
+}
+
+void PacketRouter::SetTransportWideSequenceNumber(uint16_t sequence_number) {
+  rtc::AtomicOps::ReleaseStore(&transport_seq_, sequence_number);
 }
+
+uint16_t PacketRouter::AllocateSequenceNumber() {
+  int prev_seq = rtc::AtomicOps::AcquireLoad(&transport_seq_);
+  int desired_prev_seq;
+  int new_seq;
+  do {
+    desired_prev_seq = prev_seq;
+    new_seq = (desired_prev_seq + 1) & 0xFFFF;
+    // Note: CompareAndSwap returns the actual value of transport_seq at the
+    // time the CAS operation was executed. Thus, if prev_seq is returned, the
+    // operation was successful - otherwise we need to retry. Saving the
+    // return value saves us a load on retry.
+    prev_seq = rtc::AtomicOps::CompareAndSwap(&transport_seq_, desired_prev_seq,
+                                              new_seq);
+  } while (prev_seq != desired_prev_seq);
+
+  return new_seq;
+}
+
 }  // namespace webrtc