Refactor RtpSender and SSRCDatabase a bit.

webrtc/modules/rtp_rtcp/source/rtp_sender.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 45 matching lines @@
 uint32_t ConvertMsTo24Bits(int64_t time_ms) {
   uint32_t time_24_bits =
       static_cast<uint32_t>(
           ((static_cast<uint64_t>(time_ms) << kAbsSendTimeFraction) + 500) /
           1000) &
       0x00FFFFFF;
   return time_24_bits;
 }
 }  // namespace
 
-class BitrateAggregator {
- public:
-  explicit BitrateAggregator(BitrateStatisticsObserver* bitrate_callback)
-      : callback_(bitrate_callback),
-        total_bitrate_observer_(*this),
-        retransmit_bitrate_observer_(*this),
-        ssrc_(0) {}
+BitrateAggregator::BitrateAggregator(
+    BitrateStatisticsObserver* bitrate_callback)
+    : callback_(bitrate_callback),
+      total_bitrate_observer_(*this),
+      retransmit_bitrate_observer_(*this),
+      ssrc_(0) {}
 
-  void OnStatsUpdated() const {
-    if (callback_)
-      callback_->Notify(total_bitrate_observer_.statistics(),
-                        retransmit_bitrate_observer_.statistics(),
-                        ssrc_);
+void BitrateAggregator::OnStatsUpdated() const {
+  if (callback_) {
+    callback_->Notify(total_bitrate_observer_.statistics(),
+                      retransmit_bitrate_observer_.statistics(), ssrc_);
   }
+}
 
-  Bitrate::Observer* total_bitrate_observer() {
-    return &total_bitrate_observer_;
-  }
-  Bitrate::Observer* retransmit_bitrate_observer() {
-    return &retransmit_bitrate_observer_;
-  }
+Bitrate::Observer* BitrateAggregator::total_bitrate_observer() {
+  return &total_bitrate_observer_;
+}
+Bitrate::Observer* BitrateAggregator::retransmit_bitrate_observer() {
+  return &retransmit_bitrate_observer_;
+}
 
-  void set_ssrc(uint32_t ssrc) { ssrc_ = ssrc; }
+void BitrateAggregator::set_ssrc(uint32_t ssrc) {
+  ssrc_ = ssrc;
+}
 
- private:
-  // We assume that these observers are called on the same thread, which is
-  // true for RtpSender as they are called on the Process thread.
-  class BitrateObserver : public Bitrate::Observer {
-   public:
-    explicit BitrateObserver(const BitrateAggregator& aggregator)
-        : aggregator_(aggregator) {}
+BitrateAggregator::BitrateObserver::BitrateObserver(
+    const BitrateAggregator& aggregator)
+    : aggregator_(aggregator) {}
 
-    // Implements Bitrate::Observer.
-    void BitrateUpdated(const BitrateStatistics& stats) override {
-      statistics_ = stats;
-      aggregator_.OnStatsUpdated();
-    }
+// Implements Bitrate::Observer.
+void BitrateAggregator::BitrateObserver::BitrateUpdated(
+    const BitrateStatistics& stats) {
+  statistics_ = stats;
+  aggregator_.OnStatsUpdated();
+}
 
-    BitrateStatistics statistics() const { return statistics_; }
-
-   private:
-    BitrateStatistics statistics_;
-    const BitrateAggregator& aggregator_;
-  };
-
-  BitrateStatisticsObserver* const callback_;
-  BitrateObserver total_bitrate_observer_;
-  BitrateObserver retransmit_bitrate_observer_;
-  uint32_t ssrc_;
-};
+BitrateStatistics BitrateAggregator::BitrateObserver::statistics() const {
+  return statistics_;
+}
 
 RTPSender::RTPSender(
     bool audio,
     Clock* clock,
     Transport* transport,
     RtpAudioFeedback* audio_feedback,
     RtpPacketSender* paced_sender,
     TransportSequenceNumberAllocator* sequence_number_allocator,
     TransportFeedbackObserver* transport_feedback_observer,
     BitrateStatisticsObserver* bitrate_callback,
     FrameCountObserver* frame_count_observer,
     SendSideDelayObserver* send_side_delay_observer,
-    RtcEventLog* event_log)
+    RtcEventLog* event_log,
+    SSRCDatabase* ssrc_database)
     : clock_(clock),
       // TODO(holmer): Remove this conversion when we remove the use of
       // TickTime.
       clock_delta_ms_(clock_->TimeInMilliseconds() -
                       TickTime::MillisecondTimestamp()),
       random_(clock_->TimeInMicroseconds()),
-      bitrates_(new BitrateAggregator(bitrate_callback)),
-      total_bitrate_sent_(clock, bitrates_->total_bitrate_observer()),
+      bitrates_(bitrate_callback),
+      total_bitrate_sent_(clock, bitrates_.total_bitrate_observer()),
       audio_configured_(audio),
       audio_(audio ? new RTPSenderAudio(clock, this, audio_feedback) : nullptr),
       video_(audio ? nullptr : new RTPSenderVideo(clock, this)),
       paced_sender_(paced_sender),
       transport_sequence_number_allocator_(sequence_number_allocator),
       transport_feedback_observer_(transport_feedback_observer),
       last_capture_time_ms_sent_(0),
-      send_critsect_(CriticalSectionWrapper::CreateCriticalSection()),
       transport_(transport),
       sending_media_(true),                      // Default to sending media.
       max_payload_length_(IP_PACKET_SIZE - 28),  // Default is IP-v4/UDP.
       packet_over_head_(28),
       payload_type_(-1),
       payload_type_map_(),
       rtp_header_extension_map_(),
       transmission_time_offset_(0),
       absolute_send_time_(0),
       rotation_(kVideoRotation_0),
       cvo_mode_(kCVONone),
       transport_sequence_number_(0),
       // NACK.
       nack_byte_count_times_(),
       nack_byte_count_(),
-      nack_bitrate_(clock, bitrates_->retransmit_bitrate_observer()),
+      nack_bitrate_(clock, bitrates_.retransmit_bitrate_observer()),
       packet_history_(clock),
       // Statistics
       statistics_crit_(CriticalSectionWrapper::CreateCriticalSection()),
       rtp_stats_callback_(NULL),
       frame_count_observer_(frame_count_observer),
       send_side_delay_observer_(send_side_delay_observer),
       event_log_(event_log),
       // RTP variables
       start_timestamp_forced_(false),
       start_timestamp_(0),
-      ssrc_db_(*SSRCDatabase::GetSSRCDatabase()),
+      ssrc_db_(ssrc_database),
       remote_ssrc_(0),
       sequence_number_forced_(false),
       ssrc_forced_(false),
       timestamp_(0),
       capture_time_ms_(0),
       last_timestamp_time_ms_(0),
       media_has_been_sent_(false),
       last_packet_marker_bit_(false),
       csrcs_(),
       rtx_(kRtxOff),
       rtx_payload_type_(-1),
       target_bitrate_critsect_(CriticalSectionWrapper::CreateCriticalSection()),
       target_bitrate_(0) {
   memset(nack_byte_count_times_, 0, sizeof(nack_byte_count_times_));
   memset(nack_byte_count_, 0, sizeof(nack_byte_count_));
   // We need to seed the random generator.
+  // TODO(holmer,tommi): Why?^^^ (SSRCDatabase does its own seeding).
+  // TODO(holmer,tommi): Note also that TimeInMilliseconds might return 0 on Mac
+  // early on in the process.
   srand(static_cast<uint32_t>(clock_->TimeInMilliseconds()));
-  ssrc_ = ssrc_db_.CreateSSRC();  // Can't be 0.
-  ssrc_rtx_ = ssrc_db_.CreateSSRC();  // Can't be 0.
-  bitrates_->set_ssrc(ssrc_);
+  ssrc_ = ssrc_db_->CreateSSRC();
+  RTC_DCHECK(ssrc_);
+  ssrc_rtx_ = ssrc_db_->CreateSSRC();
+  RTC_DCHECK(ssrc_rtx_);
+
+  bitrates_.set_ssrc(ssrc_);
   // Random start, 16 bits. Can't be 0.
   sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
   sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
 }
 
 RTPSender::~RTPSender() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  // TODO(tommi,holmer): We don't grab locks in the dtor before accessing member
+  // variables but we grab them in all other methods. (what's the design?)
+  // Start documenting what thread we're on in what method so that it's easier
+  // to understand performance attributes and possibly remove locks.
   if (remote_ssrc_ != 0) {
-    ssrc_db_.ReturnSSRC(remote_ssrc_);
+    ssrc_db_->ReturnSSRC(remote_ssrc_);
   }
-  ssrc_db_.ReturnSSRC(ssrc_);
+  ssrc_db_->ReturnSSRC(ssrc_);
 
-  SSRCDatabase::ReturnSSRCDatabase();
   while (!payload_type_map_.empty()) {
     std::map<int8_t, RtpUtility::Payload*>::iterator it =
         payload_type_map_.begin();
     delete it->second;
     payload_type_map_.erase(it);
   }
 }
 
 void RTPSender::SetTargetBitrate(uint32_t bitrate) {
   CriticalSectionScoped cs(target_bitrate_critsect_.get());
@@ skipping 25 matching lines @@
 
 uint32_t RTPSender::NackOverheadRate() const {
   return nack_bitrate_.BitrateLast();
 }
 
 int32_t RTPSender::SetTransmissionTimeOffset(int32_t transmission_time_offset) {
   if (transmission_time_offset > (0x800000 - 1) ||
       transmission_time_offset < -(0x800000 - 1)) {  // Word24.
     return -1;
   }
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   transmission_time_offset_ = transmission_time_offset;
   return 0;
 }
 
 int32_t RTPSender::SetAbsoluteSendTime(uint32_t absolute_send_time) {
   if (absolute_send_time > 0xffffff) {  // UWord24.
     return -1;
   }
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   absolute_send_time_ = absolute_send_time;
   return 0;
 }
 
 void RTPSender::SetVideoRotation(VideoRotation rotation) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   rotation_ = rotation;
 }
 
 int32_t RTPSender::SetTransportSequenceNumber(uint16_t sequence_number) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   transport_sequence_number_ = sequence_number;
   return 0;
 }
 
 int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
                                               uint8_t id) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   if (type == kRtpExtensionVideoRotation) {
     cvo_mode_ = kCVOInactive;
     return rtp_header_extension_map_.RegisterInactive(type, id);
   }
   return rtp_header_extension_map_.Register(type, id);
 }
 
 bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return rtp_header_extension_map_.IsRegistered(type);
 }
 
 int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return rtp_header_extension_map_.Deregister(type);
 }
 
 size_t RTPSender::RtpHeaderExtensionTotalLength() const {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return rtp_header_extension_map_.GetTotalLengthInBytes();
 }
 
 int32_t RTPSender::RegisterPayload(
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
     int8_t payload_number,
     uint32_t frequency,
     size_t channels,
     uint32_t rate) {
   assert(payload_name);
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   std::map<int8_t, RtpUtility::Payload*>::iterator it =
       payload_type_map_.find(payload_number);
 
   if (payload_type_map_.end() != it) {
     // We already use this payload type.
     RtpUtility::Payload* payload = it->second;
     assert(payload);
 
     // Check if it's the same as we already have.
@@ skipping 22 matching lines @@
   } else {
     payload = video_->CreateVideoPayload(payload_name, payload_number, rate);
   }
   if (payload) {
     payload_type_map_[payload_number] = payload;
   }
   return ret_val;
 }
 
 int32_t RTPSender::DeRegisterSendPayload(int8_t payload_type) {
-  CriticalSectionScoped lock(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   std::map<int8_t, RtpUtility::Payload*>::iterator it =
       payload_type_map_.find(payload_type);
 
   if (payload_type_map_.end() == it) {
     return -1;
   }
   RtpUtility::Payload* payload = it->second;
   delete payload;
   payload_type_map_.erase(it);
   return 0;
 }
 
 void RTPSender::SetSendPayloadType(int8_t payload_type) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   payload_type_ = payload_type;
 }
 
 int8_t RTPSender::SendPayloadType() const {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return payload_type_;
 }
 
 int RTPSender::SendPayloadFrequency() const {
   return audio_ != NULL ? audio_->AudioFrequency() : kVideoPayloadTypeFrequency;
 }
 
 int32_t RTPSender::SetMaxPayloadLength(size_t max_payload_length,
                                        uint16_t packet_over_head) {
   // Sanity check.
   RTC_DCHECK(max_payload_length >= 100 && max_payload_length <= IP_PACKET_SIZE)
       << "Invalid max payload length: " << max_payload_length;
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   max_payload_length_ = max_payload_length;
   packet_over_head_ = packet_over_head;
   return 0;
 }
 
 size_t RTPSender::MaxDataPayloadLength() const {
   int rtx;
   {
-    CriticalSectionScoped rtx_lock(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     rtx = rtx_;
   }
   if (audio_configured_) {
     return max_payload_length_ - RTPHeaderLength();
   } else {
     return max_payload_length_ - RTPHeaderLength()  // RTP overhead.
            - video_->FECPacketOverhead()            // FEC/ULP/RED overhead.
            - ((rtx) ? 2 : 0);                       // RTX overhead.
   }
 }
 
 size_t RTPSender::MaxPayloadLength() const {
   return max_payload_length_;
 }
 
 uint16_t RTPSender::PacketOverHead() const { return packet_over_head_; }
 
 void RTPSender::SetRtxStatus(int mode) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   rtx_ = mode;
 }
 
 int RTPSender::RtxStatus() const {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return rtx_;
 }
 
 void RTPSender::SetRtxSsrc(uint32_t ssrc) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   ssrc_rtx_ = ssrc;
 }
 
 uint32_t RTPSender::RtxSsrc() const {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return ssrc_rtx_;
 }
 
 void RTPSender::SetRtxPayloadType(int payload_type,
                                   int associated_payload_type) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   RTC_DCHECK_LE(payload_type, 127);
   RTC_DCHECK_LE(associated_payload_type, 127);
   if (payload_type < 0) {
     LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type;
     return;
   }
 
   rtx_payload_type_map_[associated_payload_type] = payload_type;
   rtx_payload_type_ = payload_type;
 }
 
 std::pair<int, int> RTPSender::RtxPayloadType() const {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   for (const auto& kv : rtx_payload_type_map_) {
     if (kv.second == rtx_payload_type_) {
       return std::make_pair(rtx_payload_type_, kv.first);
     }
   }
   return std::make_pair(-1, -1);
 }
 
 int32_t RTPSender::CheckPayloadType(int8_t payload_type,
                                     RtpVideoCodecTypes* video_type) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   if (payload_type < 0) {
     LOG(LS_ERROR) << "Invalid payload_type " << payload_type;
     return -1;
   }
   if (audio_configured_) {
     int8_t red_pl_type = -1;
     if (audio_->RED(&red_pl_type) == 0) {
       // We have configured RED.
       if (red_pl_type == payload_type) {
@@ skipping 21 matching lines @@
   if (!payload->audio && !audio_configured_) {
     video_->SetVideoCodecType(payload->typeSpecific.Video.videoCodecType);
     *video_type = payload->typeSpecific.Video.videoCodecType;
     video_->SetMaxConfiguredBitrateVideo(payload->typeSpecific.Video.maxRate);
   }
   return 0;
 }
 
 RTPSenderInterface::CVOMode RTPSender::ActivateCVORtpHeaderExtension() {
   if (cvo_mode_ == kCVOInactive) {
-    CriticalSectionScoped cs(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     if (rtp_header_extension_map_.SetActive(kRtpExtensionVideoRotation, true)) {
       cvo_mode_ = kCVOActivated;
     }
   }
   return cvo_mode_;
 }
 
 int32_t RTPSender::SendOutgoingData(FrameType frame_type,
                                     int8_t payload_type,
                                     uint32_t capture_timestamp,
                                     int64_t capture_time_ms,
                                     const uint8_t* payload_data,
                                     size_t payload_size,
                                     const RTPFragmentationHeader* fragmentation,
                                     const RTPVideoHeader* rtp_hdr) {
   uint32_t ssrc;
   {
     // Drop this packet if we're not sending media packets.
-    CriticalSectionScoped cs(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     ssrc = ssrc_;
     if (!sending_media_) {
       return 0;
     }
   }
   RtpVideoCodecTypes video_type = kRtpVideoGeneric;
   if (CheckPayloadType(payload_type, &video_type) != 0) {
     LOG(LS_ERROR) << "Don't send data with unknown payload type: "
                   << static_cast<int>(payload_type) << ".";
     return -1;
@@ skipping 31 matching lines @@
   }
   if (frame_count_observer_) {
     frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc);
   }
 
   return ret_val;
 }
 
 size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send) {
   {
-    CriticalSectionScoped cs(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     if ((rtx_ & kRtxRedundantPayloads) == 0)
       return 0;
   }
 
   uint8_t buffer[IP_PACKET_SIZE];
   int bytes_left = static_cast<int>(bytes_to_send);
   while (bytes_left > 0) {
     size_t length = bytes_left;
     int64_t capture_time_ms;
     if (!packet_history_.GetBestFittingPacket(buffer, &length,
@@ skipping 41 matching lines @@
                              transport_sequence_number_allocator_;
   for (; bytes > 0; bytes -= padding_bytes_in_packet) {
     if (bytes < padding_bytes_in_packet)
       bytes = padding_bytes_in_packet;
 
     uint32_t ssrc;
     uint16_t sequence_number;
     int payload_type;
     bool over_rtx;
     {
-      CriticalSectionScoped cs(send_critsect_.get());
+      rtc::CritScope lock(&send_critsect_);
       if (!timestamp_provided) {
         timestamp = timestamp_;
         capture_time_ms = capture_time_ms_;
       }
       if (rtx_ == kRtxOff) {
         // Without RTX we can't send padding in the middle of frames.
         if (!last_packet_marker_bit_)
           return 0;
         ssrc = ssrc_;
         sequence_number = sequence_number_;
@@ skipping 93 matching lines @@
     // TickTime.
     int64_t corrected_capture_tims_ms = capture_time_ms + clock_delta_ms_;
     paced_sender_->InsertPacket(
         RtpPacketSender::kNormalPriority, header.ssrc, header.sequenceNumber,
         corrected_capture_tims_ms, length - header.headerLength, true);
 
     return length;
   }
   int rtx = kRtxOff;
   {
-    CriticalSectionScoped lock(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     rtx = rtx_;
   }
   if (!PrepareAndSendPacket(data_buffer, length, capture_time_ms,
                             (rtx & kRtxRetransmitted) > 0, true)) {
     return -1;
   }
   return static_cast<int32_t>(length);
 }
 
 bool RTPSender::SendPacketToNetwork(const uint8_t* packet,
@@ skipping 77 matching lines @@
     UpdateNACKBitRate(bytes_re_sent, now);
   }
 }
 
 bool RTPSender::ProcessNACKBitRate(uint32_t now) {
   uint32_t num = 0;
   size_t byte_count = 0;
   const uint32_t kAvgIntervalMs = 1000;
   uint32_t target_bitrate = GetTargetBitrate();
 
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   if (target_bitrate == 0) {
     return true;
   }
   for (num = 0; num < NACK_BYTECOUNT_SIZE; ++num) {
     if ((now - nack_byte_count_times_[num]) > kAvgIntervalMs) {
       // Don't use data older than 1sec.
       break;
     } else {
       byte_count += nack_byte_count_[num];
     }
   }
   uint32_t time_interval = kAvgIntervalMs;
   if (num == NACK_BYTECOUNT_SIZE) {
     // More than NACK_BYTECOUNT_SIZE nack messages has been received
     // during the last msg_interval.
     if (nack_byte_count_times_[num - 1] <= now) {
       time_interval = now - nack_byte_count_times_[num - 1];
     }
   }
   return (byte_count * 8) < (target_bitrate / 1000 * time_interval);
 }
 
 void RTPSender::UpdateNACKBitRate(uint32_t bytes, int64_t now) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   if (bytes == 0)
     return;
   nack_bitrate_.Update(bytes);
   // Save bitrate statistics.
   // Shift all but first time.
   for (int i = NACK_BYTECOUNT_SIZE - 2; i >= 0; i--) {
     nack_byte_count_[i + 1] = nack_byte_count_[i];
     nack_byte_count_times_[i + 1] = nack_byte_count_times_[i];
   }
   nack_byte_count_[0] = bytes;
@@ skipping 15 matching lines @@
                                                &length,
                                                &stored_time_ms)) {
     // Packet cannot be found. Allow sending to continue.
     return true;
   }
   if (!retransmission && capture_time_ms > 0) {
     UpdateDelayStatistics(capture_time_ms, clock_->TimeInMilliseconds());
   }
   int rtx;
   {
-    CriticalSectionScoped lock(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     rtx = rtx_;
   }
   return PrepareAndSendPacket(data_buffer,
                               length,
                               capture_time_ms,
                               retransmission && (rtx & kRtxRetransmitted) > 0,
                               retransmission);
 }
 
 bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
@@ skipping 37 matching lines @@
     options.packet_id =
         UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header);
   }
 
   if (using_transport_seq && transport_feedback_observer_) {
     transport_feedback_observer_->AddPacket(options.packet_id, length, true);
   }
 
   bool ret = SendPacketToNetwork(buffer_to_send_ptr, length, options);
   if (ret) {
-    CriticalSectionScoped lock(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     media_has_been_sent_ = true;
   }
   UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx,
                  is_retransmit);
   return ret;
 }
 
 void RTPSender::UpdateRtpStats(const uint8_t* buffer,
                                size_t packet_length,
                                const RTPHeader& header,
@@ skipping 39 matching lines @@
   video_->GenericFECStatus(&fec_enabled, &pt_red, &pt_fec);
   return fec_enabled &&
       header.payloadType == pt_red &&
       buffer[header.headerLength] == pt_fec;
 }
 
 size_t RTPSender::TimeToSendPadding(size_t bytes) {
   if (audio_configured_ || bytes == 0)
     return 0;
   {
-    CriticalSectionScoped cs(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     if (!sending_media_)
       return 0;
   }
   size_t bytes_sent = TrySendRedundantPayloads(bytes);
   if (bytes_sent < bytes)
     bytes_sent += SendPadData(bytes - bytes_sent, false, 0, 0);
   return bytes_sent;
 }
 
 // TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again.
@@ skipping 51 matching lines @@
 
   // Mark the packet as sent in the history even if send failed. Dropping a
   // packet here should be treated as any other packet drop so we should be
   // ready for a retransmission.
   packet_history_.SetSent(rtp_header.sequenceNumber);
 
   if (!sent)
     return -1;
 
   {
-    CriticalSectionScoped lock(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     media_has_been_sent_ = true;
   }
   UpdateRtpStats(buffer, length, rtp_header, false, false);
   return 0;
 }
 
 void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) {
   if (!send_side_delay_observer_)
     return;
 
   uint32_t ssrc;
   int avg_delay_ms = 0;
   int max_delay_ms = 0;
   {
-    CriticalSectionScoped lock(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     ssrc = ssrc_;
   }
   {
     CriticalSectionScoped cs(statistics_crit_.get());
     // TODO(holmer): Compute this iteratively instead.
     send_delays_[now_ms] = now_ms - capture_time_ms;
     send_delays_.erase(send_delays_.begin(),
                        send_delays_.lower_bound(now_ms -
                        kSendSideDelayWindowMs));
     int num_delays = 0;
     for (auto it = send_delays_.upper_bound(now_ms - kSendSideDelayWindowMs);
          it != send_delays_.end(); ++it) {
       max_delay_ms = std::max(max_delay_ms, it->second);
       avg_delay_ms += it->second;
       ++num_delays;
     }
     if (num_delays == 0)
       return;
     avg_delay_ms = (avg_delay_ms + num_delays / 2) / num_delays;
   }
   send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms,
                                                   ssrc);
 }
 
 void RTPSender::ProcessBitrate() {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   total_bitrate_sent_.Process();
   nack_bitrate_.Process();
   if (audio_configured_) {
     return;
   }
   video_->ProcessBitrate();
 }
 
 size_t RTPSender::RTPHeaderLength() const {
-  CriticalSectionScoped lock(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   size_t rtp_header_length = kRtpHeaderLength;
   rtp_header_length += sizeof(uint32_t) * csrcs_.size();
   rtp_header_length += RtpHeaderExtensionTotalLength();
   return rtp_header_length;
 }
 
 uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   uint16_t first_allocated_sequence_number = sequence_number_;
   sequence_number_ += packets_to_send;
   return first_allocated_sequence_number;
 }
 
 void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
                                 StreamDataCounters* rtx_stats) const {
   CriticalSectionScoped lock(statistics_crit_.get());
   *rtp_stats = rtp_stats_;
   *rtx_stats = rtx_rtp_stats_;
@@ skipping 38 matching lines @@
 }
 
 int32_t RTPSender::BuildRTPheader(uint8_t* data_buffer,
                                   int8_t payload_type,
                                   bool marker_bit,
                                   uint32_t capture_timestamp,
                                   int64_t capture_time_ms,
                                   bool timestamp_provided,
                                   bool inc_sequence_number) {
   assert(payload_type >= 0);
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   if (timestamp_provided) {
     timestamp_ = start_timestamp_ + capture_timestamp;
   } else {
     // Make a unique time stamp.
     // We can't inc by the actual time, since then we increase the risk of back
     // timing.
     timestamp_++;
   }
   last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
@@ skipping 286 matching lines @@
 
   *extension_offset = block_pos;
   return ExtensionStatus::kOk;
 }
 
 void RTPSender::UpdateTransmissionTimeOffset(uint8_t* rtp_packet,
                                              size_t rtp_packet_length,
                                              const RTPHeader& rtp_header,
                                              int64_t time_diff_ms) const {
   size_t offset;
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   switch (VerifyExtension(kRtpExtensionTransmissionTimeOffset, rtp_packet,
                           rtp_packet_length, rtp_header,
                           kTransmissionTimeOffsetLength, &offset)) {
     case ExtensionStatus::kNotRegistered:
       return;
     case ExtensionStatus::kError:
       LOG(LS_WARNING) << "Failed to update transmission time offset.";
       return;
     case ExtensionStatus::kOk:
       break;
     default:
       RTC_NOTREACHED();
   }
 
   // Update transmission offset field (converting to a 90 kHz timestamp).
   ByteWriter<int32_t, 3>::WriteBigEndian(rtp_packet + offset + 1,
                                          time_diff_ms * 90);  // RTP timestamp.
 }
 
 bool RTPSender::UpdateAudioLevel(uint8_t* rtp_packet,
                                  size_t rtp_packet_length,
                                  const RTPHeader& rtp_header,
                                  bool is_voiced,
                                  uint8_t dBov) const {
   size_t offset;
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   switch (VerifyExtension(kRtpExtensionAudioLevel, rtp_packet,
                           rtp_packet_length, rtp_header, kAudioLevelLength,
                           &offset)) {
     case ExtensionStatus::kNotRegistered:
       return false;
     case ExtensionStatus::kError:
       LOG(LS_WARNING) << "Failed to update audio level.";
       return false;
     case ExtensionStatus::kOk:
       break;
     default:
       RTC_NOTREACHED();
   }
 
   rtp_packet[offset + 1] = (is_voiced ? 0x80 : 0x00) + (dBov & 0x7f);
   return true;
 }
 
 bool RTPSender::UpdateVideoRotation(uint8_t* rtp_packet,
                                     size_t rtp_packet_length,
                                     const RTPHeader& rtp_header,
                                     VideoRotation rotation) const {
   size_t offset;
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   switch (VerifyExtension(kRtpExtensionVideoRotation, rtp_packet,
                           rtp_packet_length, rtp_header, kVideoRotationLength,
                           &offset)) {
     case ExtensionStatus::kNotRegistered:
       return false;
     case ExtensionStatus::kError:
       LOG(LS_WARNING) << "Failed to update CVO.";
       return false;
     case ExtensionStatus::kOk:
       break;
     default:
       RTC_NOTREACHED();
   }
 
   rtp_packet[offset + 1] = ConvertVideoRotationToCVOByte(rotation);
   return true;
 }
 
 void RTPSender::UpdateAbsoluteSendTime(uint8_t* rtp_packet,
                                        size_t rtp_packet_length,
                                        const RTPHeader& rtp_header,
                                        int64_t now_ms) const {
   size_t offset;
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   switch (VerifyExtension(kRtpExtensionAbsoluteSendTime, rtp_packet,
                           rtp_packet_length, rtp_header,
                           kAbsoluteSendTimeLength, &offset)) {
     case ExtensionStatus::kNotRegistered:
       return;
     case ExtensionStatus::kError:
       LOG(LS_WARNING) << "Failed to update absolute send time";
       return;
     case ExtensionStatus::kOk:
       break;
     default:
       RTC_NOTREACHED();
   }
 
   // Update absolute send time field (convert ms to 24-bit unsigned with 18 bit
   // fractional part).
   ByteWriter<uint32_t, 3>::WriteBigEndian(rtp_packet + offset + 1,
                                           ConvertMsTo24Bits(now_ms));
 }
 
 uint16_t RTPSender::UpdateTransportSequenceNumber(
     uint8_t* rtp_packet,
     size_t rtp_packet_length,
     const RTPHeader& rtp_header) const {
   size_t offset;
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   switch (VerifyExtension(kRtpExtensionTransportSequenceNumber, rtp_packet,
                           rtp_packet_length, rtp_header,
                           kTransportSequenceNumberLength, &offset)) {
     case ExtensionStatus::kNotRegistered:
       return 0;
     case ExtensionStatus::kError:
       LOG(LS_WARNING) << "Failed to update transport sequence number";
       return 0;
     case ExtensionStatus::kOk:
       break;
     default:
       RTC_NOTREACHED();
   }
 
   uint16_t seq = transport_sequence_number_allocator_->AllocateSequenceNumber();
   BuildTransportSequenceNumberExtension(rtp_packet + offset, seq);
   return seq;
 }
 
 void RTPSender::SetSendingStatus(bool enabled) {
   if (enabled) {
     uint32_t frequency_hz = SendPayloadFrequency();
     uint32_t RTPtime = CurrentRtp(*clock_, frequency_hz);
 
     // Will be ignored if it's already configured via API.
     SetStartTimestamp(RTPtime, false);
   } else {
-    CriticalSectionScoped lock(send_critsect_.get());
+    rtc::CritScope lock(&send_critsect_);
     if (!ssrc_forced_) {
       // Generate a new SSRC.
-      ssrc_db_.ReturnSSRC(ssrc_);
-      ssrc_ = ssrc_db_.CreateSSRC();  // Can't be 0.
-      bitrates_->set_ssrc(ssrc_);
+      ssrc_db_->ReturnSSRC(ssrc_);
+      ssrc_ = ssrc_db_->CreateSSRC();  // Can't be 0.
+      bitrates_.set_ssrc(ssrc_);
     }
     // Don't initialize seq number if SSRC passed externally.
     if (!sequence_number_forced_ && !ssrc_forced_) {
       // Generate a new sequence number.
       sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
     }
   }
 }
 
 void RTPSender::SetSendingMediaStatus(bool enabled) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   sending_media_ = enabled;
 }
 
 bool RTPSender::SendingMedia() const {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return sending_media_;
 }
 
 uint32_t RTPSender::Timestamp() const {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return timestamp_;
 }
 
 void RTPSender::SetStartTimestamp(uint32_t timestamp, bool force) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   if (force) {
     start_timestamp_forced_ = true;
     start_timestamp_ = timestamp;
   } else {
     if (!start_timestamp_forced_) {
       start_timestamp_ = timestamp;
     }
   }
 }
 
 uint32_t RTPSender::StartTimestamp() const {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return start_timestamp_;
 }
 
 uint32_t RTPSender::GenerateNewSSRC() {
   // If configured via API, return 0.
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   if (ssrc_forced_) {
     return 0;
   }
-  ssrc_ = ssrc_db_.CreateSSRC();  // Can't be 0.
-  bitrates_->set_ssrc(ssrc_);
+  ssrc_ = ssrc_db_->CreateSSRC();  // Can't be 0.
+  bitrates_.set_ssrc(ssrc_);
   return ssrc_;
 }
 
 void RTPSender::SetSSRC(uint32_t ssrc) {
   // This is configured via the API.
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   if (ssrc_ == ssrc && ssrc_forced_) {
     return;  // Since it's same ssrc, don't reset anything.
   }
   ssrc_forced_ = true;
-  ssrc_db_.ReturnSSRC(ssrc_);
-  ssrc_db_.RegisterSSRC(ssrc);
+  ssrc_db_->ReturnSSRC(ssrc_);
+  ssrc_db_->RegisterSSRC(ssrc);
   ssrc_ = ssrc;
-  bitrates_->set_ssrc(ssrc_);
+  bitrates_.set_ssrc(ssrc_);
   if (!sequence_number_forced_) {
     sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
   }
 }
 
 uint32_t RTPSender::SSRC() const {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return ssrc_;
 }
 
 void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
   assert(csrcs.size() <= kRtpCsrcSize);
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   csrcs_ = csrcs;
 }
 
 void RTPSender::SetSequenceNumber(uint16_t seq) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   sequence_number_forced_ = true;
   sequence_number_ = seq;
 }
 
 uint16_t RTPSender::SequenceNumber() const {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   return sequence_number_;
 }
 
 // Audio.
 int32_t RTPSender::SendTelephoneEvent(uint8_t key,
                                       uint16_t time_ms,
                                       uint8_t level) {
   if (!audio_configured_) {
     return -1;
   }
@@ skipping 56 matching lines @@
     const FecProtectionParams *key_params) {
   if (audio_configured_) {
     return -1;
   }
   video_->SetFecParameters(delta_params, key_params);
   return 0;
 }
 
 void RTPSender::BuildRtxPacket(uint8_t* buffer, size_t* length,
                                uint8_t* buffer_rtx) {
-  CriticalSectionScoped cs(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   uint8_t* data_buffer_rtx = buffer_rtx;
   // Add RTX header.
   RtpUtility::RtpHeaderParser rtp_parser(
       reinterpret_cast<const uint8_t*>(buffer), *length);
 
   RTPHeader rtp_header;
   rtp_parser.Parse(&rtp_header);
 
   // Add original RTP header.
   memcpy(data_buffer_rtx, buffer, rtp_header.headerLength);
@@ skipping 34 matching lines @@
   CriticalSectionScoped cs(statistics_crit_.get());
   return rtp_stats_callback_;
 }
 
 uint32_t RTPSender::BitrateSent() const {
   return total_bitrate_sent_.BitrateLast();
 }
 
 void RTPSender::SetRtpState(const RtpState& rtp_state) {
   SetStartTimestamp(rtp_state.start_timestamp, true);
-  CriticalSectionScoped lock(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   sequence_number_ = rtp_state.sequence_number;
   sequence_number_forced_ = true;
   timestamp_ = rtp_state.timestamp;
   capture_time_ms_ = rtp_state.capture_time_ms;
   last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
   media_has_been_sent_ = rtp_state.media_has_been_sent;
 }
 
 RtpState RTPSender::GetRtpState() const {
-  CriticalSectionScoped lock(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_;
   state.start_timestamp = start_timestamp_;
   state.timestamp = timestamp_;
   state.capture_time_ms = capture_time_ms_;
   state.last_timestamp_time_ms = last_timestamp_time_ms_;
   state.media_has_been_sent = media_has_been_sent_;
 
   return state;
 }
 
 void RTPSender::SetRtxRtpState(const RtpState& rtp_state) {
-  CriticalSectionScoped lock(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
   sequence_number_rtx_ = rtp_state.sequence_number;
 }
 
 RtpState RTPSender::GetRtxRtpState() const {
-  CriticalSectionScoped lock(send_critsect_.get());
+  rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc