Switch CriticalSectionWrapper->rtc::CriticalSection in modules/audio_coding.

webrtc/modules/audio_coding/acm2/audio_coding_module_unittest_oldapi.cc

 /*
  *  Copyright (c) 2014 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 <stdio.h>
 #include <string.h>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/criticalsection.h"
 #include "webrtc/base/md5digest.h"
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread_annotations.h"
+#include "webrtc/modules/audio_coding/acm2/acm_receive_test_oldapi.h"
+#include "webrtc/modules/audio_coding/acm2/acm_send_test_oldapi.h"
 #include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
 #include "webrtc/modules/audio_coding/codecs/g711/audio_decoder_pcm.h"
 #include "webrtc/modules/audio_coding/codecs/g711/audio_encoder_pcm.h"
 #include "webrtc/modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h"
 #include "webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h"
-#include "webrtc/modules/audio_coding/acm2/acm_receive_test_oldapi.h"
-#include "webrtc/modules/audio_coding/acm2/acm_send_test_oldapi.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module_typedefs.h"
 #include "webrtc/modules/audio_coding/neteq/audio_decoder_impl.h"
 #include "webrtc/modules/audio_coding/neteq/mock/mock_audio_decoder.h"
 #include "webrtc/modules/audio_coding/neteq/tools/audio_checksum.h"
 #include "webrtc/modules/audio_coding/neteq/tools/audio_loop.h"
 #include "webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h"
 #include "webrtc/modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/output_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/packet.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/system_wrappers/include/clock.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 using ::testing::AtLeast;
 using ::testing::Invoke;
 using ::testing::_;
 
 namespace webrtc {
 
@@ skipping 36 matching lines @@
   int samples_per_packet_;
   uint8_t payload_type_;
 };
 
 class PacketizationCallbackStubOldApi : public AudioPacketizationCallback {
  public:
   PacketizationCallbackStubOldApi()
       : num_calls_(0),
         last_frame_type_(kEmptyFrame),
         last_payload_type_(-1),
-        last_timestamp_(0),
-        crit_sect_(CriticalSectionWrapper::CreateCriticalSection()) {}
+        last_timestamp_(0) {}
 
   int32_t SendData(FrameType frame_type,
                    uint8_t payload_type,
                    uint32_t timestamp,
                    const uint8_t* payload_data,
                    size_t payload_len_bytes,
                    const RTPFragmentationHeader* fragmentation) override {
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
     ++num_calls_;
     last_frame_type_ = frame_type;
     last_payload_type_ = payload_type;
     last_timestamp_ = timestamp;
     last_payload_vec_.assign(payload_data, payload_data + payload_len_bytes);
     return 0;
   }
 
   int num_calls() const {
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
     return num_calls_;
   }
 
   int last_payload_len_bytes() const {
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
     return last_payload_vec_.size();
   }
 
   FrameType last_frame_type() const {
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
     return last_frame_type_;
   }
 
   int last_payload_type() const {
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
     return last_payload_type_;
   }
 
   uint32_t last_timestamp() const {
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
     return last_timestamp_;
   }
 
   void SwapBuffers(std::vector<uint8_t>* payload) {
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
     last_payload_vec_.swap(*payload);
   }
 
  private:
   int num_calls_ GUARDED_BY(crit_sect_);
   FrameType last_frame_type_ GUARDED_BY(crit_sect_);
   int last_payload_type_ GUARDED_BY(crit_sect_);
   uint32_t last_timestamp_ GUARDED_BY(crit_sect_);
   std::vector<uint8_t> last_payload_vec_ GUARDED_BY(crit_sect_);
-  const rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
+  mutable rtc::CriticalSection crit_sect_;
 };
 
 class AudioCodingModuleTestOldApi : public ::testing::Test {
  protected:
   AudioCodingModuleTestOldApi()
       : id_(1),
         rtp_utility_(new RtpUtility(kFrameSizeSamples, kPayloadType)),
         clock_(Clock::GetRealTimeClock()) {}
 
   ~AudioCodingModuleTestOldApi() {}
@@ skipping 300 matching lines @@
 
   AudioCodingModuleMtTestOldApi()
       : AudioCodingModuleTestOldApi(),
         send_thread_(CbSendThread, this, "send"),
         insert_packet_thread_(CbInsertPacketThread, this, "insert_packet"),
         pull_audio_thread_(CbPullAudioThread, this, "pull_audio"),
         test_complete_(EventWrapper::Create()),
         send_count_(0),
         insert_packet_count_(0),
         pull_audio_count_(0),
-        crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
         next_insert_packet_time_ms_(0),
         fake_clock_(new SimulatedClock(0)) {
     clock_ = fake_clock_.get();
   }
 
   void SetUp() {
     AudioCodingModuleTestOldApi::SetUp();
     RegisterCodec();  // Must be called before the threads start below.
     StartThreads();
   }
@@ skipping 13 matching lines @@
     send_thread_.Stop();
     insert_packet_thread_.Stop();
   }
 
   EventTypeWrapper RunTest() {
     return test_complete_->Wait(10 * 60 * 1000);  // 10 minutes' timeout.
   }
 
   virtual bool TestDone() {
     if (packet_cb_.num_calls() > kNumPackets) {
-      CriticalSectionScoped lock(crit_sect_.get());
+      rtc::CritScope lock(&crit_sect_);
       if (pull_audio_count_ > kNumPullCalls) {
         // Both conditions for completion are met. End the test.
         return true;
       }
     }
     return false;
   }
 
   static bool CbSendThread(void* context) {
     return reinterpret_cast<AudioCodingModuleMtTestOldApi*>(context)
@@ skipping 17 matching lines @@
   }
 
   static bool CbInsertPacketThread(void* context) {
     return reinterpret_cast<AudioCodingModuleMtTestOldApi*>(context)
         ->CbInsertPacketImpl();
   }
 
   bool CbInsertPacketImpl() {
     SleepMs(1);
     {
-      CriticalSectionScoped lock(crit_sect_.get());
+      rtc::CritScope lock(&crit_sect_);
       if (clock_->TimeInMilliseconds() < next_insert_packet_time_ms_) {
         return true;
       }
       next_insert_packet_time_ms_ += 10;
     }
     // Now we're not holding the crit sect when calling ACM.
     ++insert_packet_count_;
     InsertPacket();
     return true;
   }
 
   static bool CbPullAudioThread(void* context) {
     return reinterpret_cast<AudioCodingModuleMtTestOldApi*>(context)
         ->CbPullAudioImpl();
   }
 
   bool CbPullAudioImpl() {
     SleepMs(1);
     {
-      CriticalSectionScoped lock(crit_sect_.get());
+      rtc::CritScope lock(&crit_sect_);
       // Don't let the insert thread fall behind.
       if (next_insert_packet_time_ms_ < clock_->TimeInMilliseconds()) {
         return true;
       }
       ++pull_audio_count_;
     }
     // Now we're not holding the crit sect when calling ACM.
     PullAudio();
     fake_clock_->AdvanceTimeMilliseconds(10);
     return true;
   }
 
   rtc::PlatformThread send_thread_;
   rtc::PlatformThread insert_packet_thread_;
   rtc::PlatformThread pull_audio_thread_;
   const rtc::scoped_ptr<EventWrapper> test_complete_;
   int send_count_;
   int insert_packet_count_;
   int pull_audio_count_ GUARDED_BY(crit_sect_);
-  const rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
+  mutable rtc::CriticalSection crit_sect_;
   int64_t next_insert_packet_time_ms_ GUARDED_BY(crit_sect_);
   rtc::scoped_ptr<SimulatedClock> fake_clock_;
 };
 
 #if defined(WEBRTC_IOS)
 #define MAYBE_DoTest DISABLED_DoTest
 #else
 #define MAYBE_DoTest DoTest
 #endif
 TEST_F(AudioCodingModuleMtTestOldApi, MAYBE_DoTest) {
@@ skipping 79 matching lines @@
 
   // Override the verification function with no-op, since iSAC produces variable
   // payload sizes.
   void VerifyEncoding() override {}
 
   // This method is the same as AudioCodingModuleMtTestOldApi::TestDone(), but
   // here it is using the constants defined in this class (i.e., shorter test
   // run).
   virtual bool TestDone() {
     if (packet_cb_.num_calls() > kNumPackets) {
-      CriticalSectionScoped lock(crit_sect_.get());
+      rtc::CritScope lock(&crit_sect_);
       if (pull_audio_count_ > kNumPullCalls) {
         // Both conditions for completion are met. End the test.
         return true;
       }
     }
     return false;
   }
 
   int last_packet_number_;
   std::vector<uint8_t> last_payload_vec_;
@@ skipping 18 matching lines @@
   static const int kPacketSizeMs = 30;
   static const int kPacketSizeSamples = kPacketSizeMs * 16;
 
   AcmReRegisterIsacMtTestOldApi()
       : AudioCodingModuleTestOldApi(),
         receive_thread_(CbReceiveThread, this, "receive"),
         codec_registration_thread_(CbCodecRegistrationThread,
                                    this,
                                    "codec_registration"),
         test_complete_(EventWrapper::Create()),
-        crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
         codec_registered_(false),
         receive_packet_count_(0),
         next_insert_packet_time_ms_(0),
         fake_clock_(new SimulatedClock(0)) {
     AudioEncoderIsac::Config config;
     config.payload_type = kPayloadType;
     isac_encoder_.reset(new AudioEncoderIsac(config));
     clock_ = fake_clock_.get();
   }
 
@@ skipping 40 matching lines @@
     return reinterpret_cast<AcmReRegisterIsacMtTestOldApi*>(context)
         ->CbReceiveImpl();
   }
 
   bool CbReceiveImpl() {
     SleepMs(1);
     const size_t max_encoded_bytes = isac_encoder_->MaxEncodedBytes();
     rtc::scoped_ptr<uint8_t[]> encoded(new uint8_t[max_encoded_bytes]);
     AudioEncoder::EncodedInfo info;
     {
-      CriticalSectionScoped lock(crit_sect_.get());
+      rtc::CritScope lock(&crit_sect_);
       if (clock_->TimeInMilliseconds() < next_insert_packet_time_ms_) {
         return true;
       }
       next_insert_packet_time_ms_ += kPacketSizeMs;
       ++receive_packet_count_;
 
       // Encode new frame.
       uint32_t input_timestamp = rtp_header_.header.timestamp;
       while (info.encoded_bytes == 0) {
         info =
@@ skipping 27 matching lines @@
     return reinterpret_cast<AcmReRegisterIsacMtTestOldApi*>(context)
         ->CbCodecRegistrationImpl();
   }
 
   bool CbCodecRegistrationImpl() {
     SleepMs(1);
     if (HasFatalFailure()) {
       // End the test early if a fatal failure (ASSERT_*) has occurred.
       test_complete_->Set();
     }
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
     if (!codec_registered_ &&
         receive_packet_count_ > kRegisterAfterNumPackets) {
       // Register the iSAC encoder.
       EXPECT_EQ(0, acm_->RegisterSendCodec(codec_));
       codec_registered_ = true;
     }
     if (codec_registered_ && receive_packet_count_ > kNumPackets) {
       test_complete_->Set();
     }
     return true;
   }
 
   rtc::PlatformThread receive_thread_;
   rtc::PlatformThread codec_registration_thread_;
   const rtc::scoped_ptr<EventWrapper> test_complete_;
-  const rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
+  mutable rtc::CriticalSection crit_sect_;
   bool codec_registered_ GUARDED_BY(crit_sect_);
   int receive_packet_count_ GUARDED_BY(crit_sect_);
   int64_t next_insert_packet_time_ms_ GUARDED_BY(crit_sect_);
   rtc::scoped_ptr<AudioEncoderIsac> isac_encoder_;
   rtc::scoped_ptr<SimulatedClock> fake_clock_;
   test::AudioLoop audio_loop_;
 };
 
 #if defined(WEBRTC_IOS)
 #define MAYBE_DoTest DISABLED_DoTest
@@ skipping 921 matching lines @@
   Run(16000, 8000, 1000);
 }
 
 TEST_F(AcmSwitchingOutputFrequencyOldApi, Toggle8KhzTo16Khz) {
   Run(8000, 16000, 1000);
 }
 
 #endif
 
 }  // namespace webrtc