Swap use of CriticalSectionWrapper with rtc::CriticalSection in voice_engine/

webrtc/voice_engine/test/auto_test/fakes/conference_transport.cc

 /*
  *  Copyright (c) 2015 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 19 matching lines @@
     if (len >= (ssrc_pos + sizeof(ssrc))) {
       ssrc = rtc::GetBE32(static_cast<const char*>(data) + ssrc_pos);
     }
     return ssrc;
   }
 }  // namespace
 
 namespace voetest {
 
 ConferenceTransport::ConferenceTransport()
-    : pq_crit_(webrtc::CriticalSectionWrapper::CreateCriticalSection()),
-      stream_crit_(webrtc::CriticalSectionWrapper::CreateCriticalSection()),
-      packet_event_(webrtc::EventWrapper::Create()),
+    : packet_event_(webrtc::EventWrapper::Create()),
       thread_(Run, this, "ConferenceTransport"),
       rtt_ms_(0),
       stream_count_(0),
       rtp_header_parser_(webrtc::RtpHeaderParser::Create()) {
   rtp_header_parser_->
       RegisterRtpHeaderExtension(webrtc::kRtpExtensionAudioLevel,
                                  kAudioLevelHeaderId);
 
   local_voe_ = webrtc::VoiceEngine::Create();
   local_base_ = webrtc::VoEBase::GetInterface(local_voe_);
@@ skipping 60 matching lines @@
   return true;
 }
 
 bool ConferenceTransport::SendRtcp(const uint8_t* data, size_t len) {
   StorePacket(Packet::Rtcp, data, len);
   return true;
 }
 
 int ConferenceTransport::GetReceiverChannelForSsrc(unsigned int sender_ssrc)
     const {
-  webrtc::CriticalSectionScoped lock(stream_crit_.get());
+  rtc::CritScope lock(&stream_crit_);
   auto it = streams_.find(sender_ssrc);
   if (it != streams_.end()) {
     return it->second.second;
   }
   return -1;
 }
 
 void ConferenceTransport::StorePacket(Packet::Type type,
                                       const void* data,
                                       size_t len) {
   {
-    webrtc::CriticalSectionScoped lock(pq_crit_.get());
+    rtc::CritScope lock(&pq_crit_);
     packet_queue_.push_back(Packet(type, data, len, rtc::Time()));
   }
   packet_event_->Set();
 }
 
 // This simulates the flow of RTP and RTCP packets. Complications like that
 // a packet is first sent to the reflector, and then forwarded to the receiver
 // are simplified, in this particular case, to a direct link between the sender
 // and the receiver.
 void ConferenceTransport::SendPacket(const Packet& packet) {
@@ skipping 45 matching lines @@
     case webrtc::kEventTimeout:
       return true;
     case webrtc::kEventError:
       ADD_FAILURE() << "kEventError encountered.";
       return true;
   }
 
   while (true) {
     Packet packet;
     {
-      webrtc::CriticalSectionScoped lock(pq_crit_.get());
+      rtc::CritScope lock(&pq_crit_);
       if (packet_queue_.empty())
         break;
       packet = packet_queue_.front();
       packet_queue_.pop_front();
     }
 
     int32_t elapsed_time_ms = rtc::TimeSince(packet.send_time_ms_);
     int32_t sleep_ms = rtt_ms_ / 2 - elapsed_time_ms;
     if (sleep_ms > 0) {
       // Every packet should be delayed by half of RTT.
@@ skipping 26 matching lines @@
 
   const int new_receiver = local_base_->CreateChannel();
   EXPECT_EQ(0, local_base_->AssociateSendChannel(new_receiver, local_sender_));
 
   EXPECT_EQ(0, local_network_->RegisterExternalTransport(new_receiver, *this));
   // Receive channels have to have the same SSRC in order to send receiver
   // reports with this SSRC.
   EXPECT_EQ(0, local_rtp_rtcp_->SetLocalSSRC(new_receiver, kLocalSsrc));
 
   {
-    webrtc::CriticalSectionScoped lock(stream_crit_.get());
+    rtc::CritScope lock(&stream_crit_);
     streams_[remote_ssrc] = std::make_pair(new_sender, new_receiver);
   }
   return remote_ssrc;  // remote ssrc used as stream id.
 }
 
 bool ConferenceTransport::RemoveStream(unsigned int id) {
-  webrtc::CriticalSectionScoped lock(stream_crit_.get());
+  rtc::CritScope lock(&stream_crit_);
   auto it = streams_.find(id);
   if (it == streams_.end()) {
     return false;
   }
   EXPECT_EQ(0, remote_network_->
       DeRegisterExternalTransport(it->second.second));
   EXPECT_EQ(0, local_network_->
       DeRegisterExternalTransport(it->second.first));
   EXPECT_EQ(0, remote_base_->DeleteChannel(it->second.second));
   EXPECT_EQ(0, local_base_->DeleteChannel(it->second.first));
@@ skipping 13 matching lines @@
 bool ConferenceTransport::GetReceiverStatistics(unsigned int id,
                                                 webrtc::CallStatistics* stats) {
   int dst = GetReceiverChannelForSsrc(id);
   if (dst == -1) {
     return false;
   }
   EXPECT_EQ(0, local_rtp_rtcp_->GetRTCPStatistics(dst, *stats));
   return true;
 }
 }  // namespace voetest