cleanup RTCPSender

webrtc/modules/rtp_rtcp/source/rtcp_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.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
 
-#include <assert.h>  // assert
 #include <string.h>  // memcpy
 
-#include <algorithm>  // min
-#include <limits>     // max
-#include <utility>
-
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/call.h"
 #include "webrtc/call/rtc_event_log.h"
 #include "webrtc/common_types.h"
-#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 
 namespace webrtc {
 
-using RTCPUtility::RTCPCnameInformation;
-
 NACKStringBuilder::NACKStringBuilder()
     : stream_(""), count_(0), prevNack_(0), consecutive_(false) {}
 
 NACKStringBuilder::~NACKStringBuilder() {}
 
 void NACKStringBuilder::PushNACK(uint16_t nack) {
   if (count_ == 0) {
     stream_ << nack;
   } else if (nack == prevNack_ + 1) {
     consecutive_ = true;
@@ skipping 62 matching lines @@
 };
 
 class RTCPSender::RtcpContext {
  public:
   RtcpContext(const FeedbackState& feedback_state,
               int32_t nack_size,
               const uint16_t* nack_list,
               bool repeat,
               uint64_t picture_id,
               uint32_t ntp_sec,
-              uint32_t ntp_frac,
-              PacketContainer* container)
+              uint32_t ntp_frac)
       : feedback_state_(feedback_state),
         nack_size_(nack_size),
         nack_list_(nack_list),
         repeat_(repeat),
         picture_id_(picture_id),
         ntp_sec_(ntp_sec),
-        ntp_frac_(ntp_frac),
-        container_(container) {}
-
-  virtual ~RtcpContext() {}
+        ntp_frac_(ntp_frac) {}
 
   const FeedbackState& feedback_state_;
   const int32_t nack_size_;
   const uint16_t* nack_list_;
   const bool repeat_;
   const uint64_t picture_id_;
   const uint32_t ntp_sec_;
   const uint32_t ntp_frac_;
-
-  PacketContainer* const container_;
 };
 
 RTCPSender::RTCPSender(
     bool audio,
     Clock* clock,
     ReceiveStatistics* receive_statistics,
     RtcpPacketTypeCounterObserver* packet_type_counter_observer,
     RtcEventLog* event_log,
     Transport* outgoing_transport)
     : audio_(audio),
       clock_(clock),
       random_(clock_->TimeInMicroseconds()),
       method_(RtcpMode::kOff),
       event_log_(event_log),
       transport_(outgoing_transport),
-
-      critical_section_rtcp_sender_(
-          CriticalSectionWrapper::CreateCriticalSection()),
       using_nack_(false),
       sending_(false),
       remb_enabled_(false),
       next_time_to_send_rtcp_(0),
       start_timestamp_(0),
       last_rtp_timestamp_(0),
       last_frame_capture_time_ms_(-1),
       ssrc_(0),
       remote_ssrc_(0),
       receive_statistics_(receive_statistics),
@@ skipping 30 matching lines @@
   builders_[kRtcpNack] = &RTCPSender::BuildNACK;
   builders_[kRtcpXrVoipMetric] = &RTCPSender::BuildVoIPMetric;
   builders_[kRtcpXrReceiverReferenceTime] =
       &RTCPSender::BuildReceiverReferenceTime;
   builders_[kRtcpXrDlrrReportBlock] = &RTCPSender::BuildDlrr;
 }
 
 RTCPSender::~RTCPSender() {}
 
 RtcpMode RTCPSender::Status() const {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   return method_;
 }
 
 void RTCPSender::SetRTCPStatus(RtcpMode method) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   method_ = method;
 
   if (method == RtcpMode::kOff)
     return;
   next_time_to_send_rtcp_ =
       clock_->TimeInMilliseconds() +
       (audio_ ? RTCP_INTERVAL_AUDIO_MS / 2 : RTCP_INTERVAL_VIDEO_MS / 2);
 }
 
 bool RTCPSender::Sending() const {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   return sending_;
 }
 
 int32_t RTCPSender::SetSendingStatus(const FeedbackState& feedback_state,
                                      bool sending) {
   bool sendRTCPBye = false;
   {
-    CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+    rtc::CritScope lock(&critical_section_rtcp_sender_);
 
     if (method_ != RtcpMode::kOff) {
       if (sending == false && sending_ == true) {
         // Trigger RTCP bye
         sendRTCPBye = true;
       }
     }
     sending_ = sending;
   }
   if (sendRTCPBye)
     return SendRTCP(feedback_state, kRtcpBye);
   return 0;
 }
 
 bool RTCPSender::REMB() const {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   return remb_enabled_;
 }
 
 void RTCPSender::SetREMBStatus(bool enable) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   remb_enabled_ = enable;
 }
 
 void RTCPSender::SetREMBData(uint32_t bitrate,
                              const std::vector<uint32_t>& ssrcs) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   remb_bitrate_ = bitrate;
   remb_ssrcs_ = ssrcs;
 
   if (remb_enabled_)
     SetFlag(kRtcpRemb, false);
   // Send a REMB immediately if we have a new REMB. The frequency of REMBs is
   // throttled by the caller.
   next_time_to_send_rtcp_ = clock_->TimeInMilliseconds();
 }
 
 bool RTCPSender::TMMBR() const {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   return IsFlagPresent(RTCPPacketType::kRtcpTmmbr);
 }
 
 void RTCPSender::SetTMMBRStatus(bool enable) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   if (enable) {
     SetFlag(RTCPPacketType::kRtcpTmmbr, false);
   } else {
     ConsumeFlag(RTCPPacketType::kRtcpTmmbr, true);
   }
 }
 
 void RTCPSender::SetStartTimestamp(uint32_t start_timestamp) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   start_timestamp_ = start_timestamp;
 }
 
 void RTCPSender::SetLastRtpTime(uint32_t rtp_timestamp,
                                 int64_t capture_time_ms) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   last_rtp_timestamp_ = rtp_timestamp;
   if (capture_time_ms < 0) {
     // We don't currently get a capture time from VoiceEngine.
     last_frame_capture_time_ms_ = clock_->TimeInMilliseconds();
   } else {
     last_frame_capture_time_ms_ = capture_time_ms;
   }
 }
 
 void RTCPSender::SetSSRC(uint32_t ssrc) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
 
   if (ssrc_ != 0) {
     // not first SetSSRC, probably due to a collision
     // schedule a new RTCP report
     // make sure that we send a RTP packet
     next_time_to_send_rtcp_ = clock_->TimeInMilliseconds() + 100;
   }
   ssrc_ = ssrc;
 }
 
 void RTCPSender::SetRemoteSSRC(uint32_t ssrc) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   remote_ssrc_ = ssrc;
 }
 
 int32_t RTCPSender::SetCNAME(const char* c_name) {
   if (!c_name)
     return -1;
 
   RTC_DCHECK_LT(strlen(c_name), static_cast<size_t>(RTCP_CNAME_SIZE));
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   cname_ = c_name;
   return 0;
 }
 
 int32_t RTCPSender::AddMixedCNAME(uint32_t SSRC, const char* c_name) {
-  assert(c_name);
+  RTC_DCHECK(c_name);
   RTC_DCHECK_LT(strlen(c_name), static_cast<size_t>(RTCP_CNAME_SIZE));
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   if (csrc_cnames_.size() >= kRtpCsrcSize)
     return -1;
 
   csrc_cnames_[SSRC] = c_name;
   return 0;
 }
 
 int32_t RTCPSender::RemoveMixedCNAME(uint32_t SSRC) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   auto it = csrc_cnames_.find(SSRC);
 
   if (it == csrc_cnames_.end())
     return -1;
 
   csrc_cnames_.erase(it);
   return 0;
 }
 
 bool RTCPSender::TimeToSendRTCPReport(bool sendKeyframeBeforeRTP) const {
@@ skipping 50 matching lines @@
      4. The calculated interval T is set to a number uniformly distributed
         between 0.5 and 1.5 times the deterministic calculated interval.
 
      5. The resulting value of T is divided by e-3/2=1.21828 to compensate
         for the fact that the timer reconsideration algorithm converges to
         a value of the RTCP bandwidth below the intended average
   */
 
   int64_t now = clock_->TimeInMilliseconds();
 
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
 
   if (method_ == RtcpMode::kOff)
     return false;
 
   if (!audio_ && sendKeyframeBeforeRTP) {
     // for video key-frames we want to send the RTCP before the large key-frame
     // if we have a 100 ms margin
     now += RTCP_SEND_BEFORE_KEY_FRAME_MS;
   }
 
   if (now >= next_time_to_send_rtcp_) {
     return true;
   } else if (now < 0x0000ffff &&
              next_time_to_send_rtcp_ > 0xffff0000) {  // 65 sec margin
     // wrap
     return true;
   }
   return false;
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildSR(const RtcpContext& ctx) {
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSR(const RtcpContext& ctx) {
   // The timestamp of this RTCP packet should be estimated as the timestamp of
   // the frame being captured at this moment. We are calculating that
   // timestamp as the last frame's timestamp + the time since the last frame
   // was captured.
   uint32_t rtp_timestamp =
       start_timestamp_ + last_rtp_timestamp_ +
       (clock_->TimeInMilliseconds() - last_frame_capture_time_ms_) *
           (ctx.feedback_state_.frequency_hz / 1000);
 
   rtcp::SenderReport* report = new rtcp::SenderReport();
   report->From(ssrc_);
   report->WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
   report->WithRtpTimestamp(rtp_timestamp);
   report->WithPacketCount(ctx.feedback_state_.packets_sent);
   report->WithOctetCount(ctx.feedback_state_.media_bytes_sent);
 
   for (auto it : report_blocks_)
     report->WithReportBlock(it.second);
 
   report_blocks_.clear();
 
-  return rtc::scoped_ptr<rtcp::SenderReport>(report);
+  return std::unique_ptr<rtcp::RtcpPacket>(report);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildSDES(
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSDES(
     const RtcpContext& ctx) {
   size_t length_cname = cname_.length();
   RTC_CHECK_LT(length_cname, static_cast<size_t>(RTCP_CNAME_SIZE));
 
   rtcp::Sdes* sdes = new rtcp::Sdes();
   sdes->WithCName(ssrc_, cname_);
 
   for (const auto it : csrc_cnames_)
     sdes->WithCName(it.first, it.second);
 
-  return rtc::scoped_ptr<rtcp::Sdes>(sdes);
+  return std::unique_ptr<rtcp::RtcpPacket>(sdes);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildRR(const RtcpContext& ctx) {
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRR(const RtcpContext& ctx) {
   rtcp::ReceiverReport* report = new rtcp::ReceiverReport();
   report->From(ssrc_);
   for (auto it : report_blocks_)
     report->WithReportBlock(it.second);
 
   report_blocks_.clear();
-  return rtc::scoped_ptr<rtcp::ReceiverReport>(report);
+  return std::unique_ptr<rtcp::RtcpPacket>(report);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildPLI(const RtcpContext& ctx) {
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildPLI(const RtcpContext& ctx) {
   rtcp::Pli* pli = new rtcp::Pli();
   pli->From(ssrc_);
   pli->To(remote_ssrc_);
 
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::PLI");
   ++packet_type_counter_.pli_packets;
   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_PLICount",
                     ssrc_, packet_type_counter_.pli_packets);
 
-  return rtc::scoped_ptr<rtcp::Pli>(pli);
+  return std::unique_ptr<rtcp::RtcpPacket>(pli);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) {
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) {
   if (!ctx.repeat_)
     ++sequence_number_fir_;  // Do not increase if repetition.
 
   rtcp::Fir* fir = new rtcp::Fir();
   fir->From(ssrc_);
   fir->WithRequestTo(remote_ssrc_, sequence_number_fir_);
 
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::FIR");
   ++packet_type_counter_.fir_packets;
   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_FIRCount",
                     ssrc_, packet_type_counter_.fir_packets);
 
-  return rtc::scoped_ptr<rtcp::Fir>(fir);
+  return std::unique_ptr<rtcp::RtcpPacket>(fir);
 }
 
 /*
     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |            First        |        Number           | PictureID |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildSLI(const RtcpContext& ctx) {
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSLI(const RtcpContext& ctx) {
   rtcp::Sli* sli = new rtcp::Sli();
   sli->From(ssrc_);
   sli->To(remote_ssrc_);
   // Crop picture id to 6 least significant bits.
   sli->WithPictureId(ctx.picture_id_ & 0x3F);
 
-  return rtc::scoped_ptr<rtcp::Sli>(sli);
+  return std::unique_ptr<rtcp::RtcpPacket>(sli);
 }
 
 /*
     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |      PB       |0| Payload Type|    Native RPSI bit string     |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |   defined per codec          ...                | Padding (0) |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
 /*
 *    Note: not generic made for VP8
 */
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildRPSI(
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRPSI(
     const RtcpContext& ctx) {
   if (ctx.feedback_state_.send_payload_type == 0xFF)
     return nullptr;
 
   rtcp::Rpsi* rpsi = new rtcp::Rpsi();
   rpsi->From(ssrc_);
   rpsi->To(remote_ssrc_);
   rpsi->WithPayloadType(ctx.feedback_state_.send_payload_type);
   rpsi->WithPictureId(ctx.picture_id_);
 
-  return rtc::scoped_ptr<rtcp::Rpsi>(rpsi);
+  return std::unique_ptr<rtcp::RtcpPacket>(rpsi);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildREMB(
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildREMB(
     const RtcpContext& ctx) {
   rtcp::Remb* remb = new rtcp::Remb();
   remb->From(ssrc_);
   for (uint32_t ssrc : remb_ssrcs_)
     remb->AppliesTo(ssrc);
   remb->WithBitrateBps(remb_bitrate_);
 
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::REMB");
 
-  return rtc::scoped_ptr<rtcp::Remb>(remb);
+  return std::unique_ptr<rtcp::RtcpPacket>(remb);
 }
 
 void RTCPSender::SetTargetBitrate(unsigned int target_bitrate) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   tmmbr_send_ = target_bitrate / 1000;
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBR(
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBR(
     const RtcpContext& ctx) {
   if (ctx.feedback_state_.module == nullptr)
     return nullptr;
   // Before sending the TMMBR check the received TMMBN, only an owner is
   // allowed to raise the bitrate:
   // * If the sender is an owner of the TMMBN -> send TMMBR
   // * If not an owner but the TMMBR would enter the TMMBN -> send TMMBR
 
   // get current bounding set from RTCP receiver
   bool tmmbrOwner = false;
@@ skipping 37 matching lines @@
     return nullptr;
 
   rtcp::Tmmbr* tmmbr = new rtcp::Tmmbr();
   tmmbr->From(ssrc_);
   rtcp::TmmbItem request;
   request.set_ssrc(remote_ssrc_);
   request.set_bitrate_bps(tmmbr_send_ * 1000);
   request.set_packet_overhead(packet_oh_send_);
   tmmbr->WithTmmbr(request);
 
-  return rtc::scoped_ptr<rtcp::Tmmbr>(tmmbr);
+  return std::unique_ptr<rtcp::RtcpPacket>(tmmbr);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBN(
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBN(
     const RtcpContext& ctx) {
   TMMBRSet* boundingSet = tmmbr_help_.BoundingSetToSend();
   if (boundingSet == nullptr)
     return nullptr;
 
   rtcp::Tmmbn* tmmbn = new rtcp::Tmmbn();
   tmmbn->From(ssrc_);
   for (uint32_t i = 0; i < boundingSet->lengthOfSet(); i++) {
     if (boundingSet->Tmmbr(i) > 0) {
       tmmbn->WithTmmbr(boundingSet->Ssrc(i), boundingSet->Tmmbr(i),
                        boundingSet->PacketOH(i));
     }
   }
 
-  return rtc::scoped_ptr<rtcp::Tmmbn>(tmmbn);
+  return std::unique_ptr<rtcp::RtcpPacket>(tmmbn);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) {
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) {
   rtcp::App* app = new rtcp::App();
   app->From(ssrc_);
   app->WithSubType(app_sub_type_);
   app->WithName(app_name_);
   app->WithData(app_data_.get(), app_length_);
 
-  return rtc::scoped_ptr<rtcp::App>(app);
+  return std::unique_ptr<rtcp::RtcpPacket>(app);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK(
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK(
     const RtcpContext& ctx) {
   rtcp::Nack* nack = new rtcp::Nack();
   nack->From(ssrc_);
   nack->To(remote_ssrc_);
   nack->WithList(ctx.nack_list_, ctx.nack_size_);
 
   // Report stats.
   NACKStringBuilder stringBuilder;
   for (int idx = 0; idx < ctx.nack_size_; ++idx) {
     stringBuilder.PushNACK(ctx.nack_list_[idx]);
     nack_stats_.ReportRequest(ctx.nack_list_[idx]);
   }
   packet_type_counter_.nack_requests = nack_stats_.requests();
   packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests();
 
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::NACK", "nacks",
                        TRACE_STR_COPY(stringBuilder.GetResult().c_str()));
   ++packet_type_counter_.nack_packets;
   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_NACKCount",
                     ssrc_, packet_type_counter_.nack_packets);
 
-  return rtc::scoped_ptr<rtcp::Nack>(nack);
+  return std::unique_ptr<rtcp::RtcpPacket>(nack);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildBYE(const RtcpContext& ctx) {
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildBYE(const RtcpContext& ctx) {
   rtcp::Bye* bye = new rtcp::Bye();
   bye->From(ssrc_);
   for (uint32_t csrc : csrcs_)
     bye->WithCsrc(csrc);
 
-  return rtc::scoped_ptr<rtcp::Bye>(bye);
+  return std::unique_ptr<rtcp::RtcpPacket>(bye);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime(
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime(
     const RtcpContext& ctx) {
 
   rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
   xr->From(ssrc_);
 
   rtcp::Rrtr rrtr;
   rrtr.WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
 
   xr->WithRrtr(rrtr);
 
   // TODO(sprang): Merge XR report sending to contain all of RRTR, DLRR, VOIP?
 
-  return rtc::scoped_ptr<rtcp::RtcpPacket>(xr);
+  return std::unique_ptr<rtcp::RtcpPacket>(xr);
 }
 
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildDlrr(
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildDlrr(
     const RtcpContext& ctx) {
   rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
   xr->From(ssrc_);
 
   rtcp::Dlrr dlrr;
   const RtcpReceiveTimeInfo& info = ctx.feedback_state_.last_xr_rr;
   dlrr.WithDlrrItem(info.sourceSSRC, info.lastRR, info.delaySinceLastRR);
 
   xr->WithDlrr(dlrr);
 
-  return rtc::scoped_ptr<rtcp::RtcpPacket>(xr);
+  return std::unique_ptr<rtcp::RtcpPacket>(xr);
 }
 
 // TODO(sprang): Add a unit test for this, or remove if the code isn't used.
-rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildVoIPMetric(
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildVoIPMetric(
     const RtcpContext& context) {
   rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
   xr->From(ssrc_);
 
   rtcp::VoipMetric voip;
   voip.To(remote_ssrc_);
   voip.WithVoipMetric(xr_voip_metric_);
 
   xr->WithVoipMetric(voip);
 
-  return rtc::scoped_ptr<rtcp::RtcpPacket>(xr);
+  return std::unique_ptr<rtcp::RtcpPacket>(xr);
 }
 
 int32_t RTCPSender::SendRTCP(const FeedbackState& feedback_state,
                              RTCPPacketType packetType,
                              int32_t nack_size,
                              const uint16_t* nack_list,
                              bool repeat,
                              uint64_t pictureID) {
   return SendCompoundRTCP(
       feedback_state, std::set<RTCPPacketType>(&packetType, &packetType + 1),
       nack_size, nack_list, repeat, pictureID);
 }
 
 int32_t RTCPSender::SendCompoundRTCP(
     const FeedbackState& feedback_state,
     const std::set<RTCPPacketType>& packet_types,
     int32_t nack_size,
     const uint16_t* nack_list,
     bool repeat,
     uint64_t pictureID) {
   PacketContainer container(transport_, event_log_);
   {
-    CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+    rtc::CritScope lock(&critical_section_rtcp_sender_);
     if (method_ == RtcpMode::kOff) {
       LOG(LS_WARNING) << "Can't send rtcp if it is disabled.";
       return -1;
     }
 
     // We need to send our NTP even if we haven't received any reports.
     uint32_t ntp_sec;
     uint32_t ntp_frac;
     clock_->CurrentNtp(ntp_sec, ntp_frac);
     RtcpContext context(feedback_state, nack_size, nack_list, repeat, pictureID,
-                        ntp_sec, ntp_frac, &container);
+                        ntp_sec, ntp_frac);
 
     PrepareReport(packet_types, feedback_state);
 
-    rtc::scoped_ptr<rtcp::RtcpPacket> packet_bye;
+    std::unique_ptr<rtcp::RtcpPacket> packet_bye;
 
     auto it = report_flags_.begin();
     while (it != report_flags_.end()) {
       auto builder_it = builders_.find(it->type);
       RTC_DCHECK(builder_it != builders_.end());
       if (it->is_volatile) {
         report_flags_.erase(it++);
       } else {
         ++it;
       }
 
       BuilderFunc func = builder_it->second;
-      rtc::scoped_ptr<rtcp::RtcpPacket> packet = (this->*func)(context);
+      std::unique_ptr<rtcp::RtcpPacket> packet = (this->*func)(context);
       if (packet.get() == nullptr)
         return -1;
       // If there is a BYE, don't append now - save it and append it
       // at the end later.
       if (builder_it->first == kRtcpBye) {
         packet_bye = std::move(packet);
       } else {
         container.Append(packet.release());
       }
     }
@@ skipping 116 matching lines @@
     uint32_t receiveTime = feedback_state.last_rr_ntp_secs & 0x0000FFFF;
     receiveTime <<= 16;
     receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16;
 
     block->WithDelayLastSr(now - receiveTime);
   }
   return true;
 }
 
 void RTCPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
-  assert(csrcs.size() <= kRtpCsrcSize);
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  RTC_DCHECK_LE(csrcs.size(), static_cast<size_t>(kRtpCsrcSize));
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   csrcs_ = csrcs;
 }
 
 int32_t RTCPSender::SetApplicationSpecificData(uint8_t subType,
                                                uint32_t name,
                                                const uint8_t* data,
                                                uint16_t length) {
   if (length % 4 != 0) {
     LOG(LS_ERROR) << "Failed to SetApplicationSpecificData.";
     return -1;
   }
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
 
   SetFlag(kRtcpApp, true);
   app_sub_type_ = subType;
   app_name_ = name;
   app_data_.reset(new uint8_t[length]);
   app_length_ = length;
   memcpy(app_data_.get(), data, length);
   return 0;
 }
 
 int32_t RTCPSender::SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   memcpy(&xr_voip_metric_, VoIPMetric, sizeof(RTCPVoIPMetric));
 
   SetFlag(kRtcpXrVoipMetric, true);
   return 0;
 }
 
 void RTCPSender::SendRtcpXrReceiverReferenceTime(bool enable) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   xr_send_receiver_reference_time_enabled_ = enable;
 }
 
 bool RTCPSender::RtcpXrReceiverReferenceTime() const {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
   return xr_send_receiver_reference_time_enabled_;
 }
 
 // no callbacks allowed inside this function
 int32_t RTCPSender::SetTMMBN(const TMMBRSet* boundingSet) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
 
   if (0 == tmmbr_help_.SetTMMBRBoundingSetToSend(boundingSet)) {
     SetFlag(kRtcpTmmbn, true);
     return 0;
   }
   return -1;
 }
 
 void RTCPSender::SetFlag(RTCPPacketType type, bool is_volatile) {
   report_flags_.insert(ReportFlag(type, is_volatile));
@@ skipping 50 matching lines @@
     // RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Sender);
     // but we can't because of an incorrect warning (C4822) in MVS 2013.
   } sender(transport_, event_log_);
 
   uint8_t buffer[IP_PACKET_SIZE];
   return packet.BuildExternalBuffer(buffer, IP_PACKET_SIZE, &sender) &&
          !sender.send_failure_;
 }
 
 }  // namespace webrtc