Remove more CriticalSectionWrappers.

webrtc/modules/media_file/media_file_impl.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 <assert.h>
 
 #include "webrtc/base/format_macros.h"
 #include "webrtc/modules/media_file/media_file_impl.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 namespace webrtc {
 MediaFile* MediaFile::CreateMediaFile(const int32_t id)
 {
     return new MediaFileImpl(id);
 }
 
 void MediaFile::DestroyMediaFile(MediaFile* module)
 {
     delete static_cast<MediaFileImpl*>(module);
 }
 
 MediaFileImpl::MediaFileImpl(const int32_t id)
     : _id(id),
-      _crit(CriticalSectionWrapper::CreateCriticalSection()),
-      _callbackCrit(CriticalSectionWrapper::CreateCriticalSection()),
       _ptrFileUtilityObj(NULL),
       codec_info_(),
       _ptrInStream(NULL),
       _ptrOutStream(NULL),
       _fileFormat((FileFormats)-1),
       _recordDurationMs(0),
       _playoutPositionMs(0),
       _notificationMs(0),
       _playingActive(false),
       _recordingActive(false),
       _isStereo(false),
       _openFile(false),
       _fileName(),
       _ptrCallback(NULL)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceFile, id, "Created");
 
     codec_info_.plname[0] = '\0';
     _fileName[0] = '\0';
 }
 
 
 MediaFileImpl::~MediaFileImpl()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceFile, _id, "~MediaFileImpl()");
     {
-        CriticalSectionScoped lock(_crit);
+        rtc::CritScope lock(&_crit);
 
         if(_playingActive)
         {
             StopPlaying();
         }
 
         if(_recordingActive)
         {
             StopRecording();
         }
 
         delete _ptrFileUtilityObj;
 
         if(_openFile)
         {
             delete _ptrInStream;
             _ptrInStream = NULL;
             delete _ptrOutStream;
             _ptrOutStream = NULL;
         }
     }
-
-    delete _crit;
-    delete _callbackCrit;
 }
 
 int64_t MediaFileImpl::TimeUntilNextProcess()
 {
     WEBRTC_TRACE(
         kTraceWarning,
         kTraceFile,
         _id,
         "TimeUntilNextProcess: This method is not used by MediaFile class.");
     return -1;
@@ skipping 17 matching lines @@
 
     if(buffer == NULL || bufferLengthInBytes == 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "Buffer pointer or length is NULL!");
         return -1;
     }
 
     int32_t bytesRead = 0;
     {
-        CriticalSectionScoped lock(_crit);
+        rtc::CritScope lock(&_crit);
 
         if(!_playingActive)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                          "Not currently playing!");
             return -1;
         }
 
         if(!_ptrFileUtilityObj)
         {
@@ skipping 73 matching lines @@
         }
     }
     else
     {
         // If no bytes were read assume end of file.
         StopPlaying();
         playEnded = true;
     }
 
     // Only _callbackCrit may and should be taken when making callbacks.
-    CriticalSectionScoped lock(_callbackCrit);
+    rtc::CritScope lock(&_callbackCrit);
     if(_ptrCallback)
     {
         if(callbackNotifyMs)
         {
             _ptrCallback->PlayNotification(_id, callbackNotifyMs);
         }
         if(playEnded)
         {
             _ptrCallback->PlayFileEnded(_id);
         }
@@ skipping 18 matching lines @@
     if(bufferLeft == NULL || bufferRight == NULL || bufferLengthInBytes == 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "A buffer pointer or the length is NULL!");
         return -1;
     }
 
     bool playEnded = false;
     uint32_t callbackNotifyMs = 0;
     {
-        CriticalSectionScoped lock(_crit);
+        rtc::CritScope lock(&_crit);
 
         if(!_playingActive || !_isStereo)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                          "Not currently playing stereo!");
             return -1;
         }
 
         if(!_ptrFileUtilityObj)
         {
@@ skipping 40 matching lines @@
             }
         }
         else
         {
             // If no bytes were read assume end of file.
             StopPlaying();
             playEnded = true;
         }
     }
 
-    CriticalSectionScoped lock(_callbackCrit);
+    rtc::CritScope lock(&_callbackCrit);
     if(_ptrCallback)
     {
         if(callbackNotifyMs)
         {
             _ptrCallback->PlayNotification(_id, callbackNotifyMs);
         }
         if(playEnded)
         {
             _ptrCallback->PlayFileEnded(_id);
         }
@@ skipping 52 matching lines @@
     }
 
     if(StartPlayingStream(*inputStream, loop, notificationTimeMs,
                           format, codecInst, startPointMs, stopPointMs) == -1)
     {
         inputStream->CloseFile();
         delete inputStream;
         return -1;
     }
 
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     _openFile = true;
     strncpy(_fileName, fileName, sizeof(_fileName));
     _fileName[sizeof(_fileName) - 1] = '\0';
     return 0;
 }
 
 int32_t MediaFileImpl::StartPlayingAudioStream(
     InStream& stream,
     const uint32_t notificationTimeMs,
     const FileFormats format,
@@ skipping 17 matching lines @@
     if(!ValidFileFormat(format,codecInst))
     {
         return -1;
     }
 
     if(!ValidFilePositions(startPointMs,stopPointMs))
     {
         return -1;
     }
 
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     if(_playingActive || _recordingActive)
     {
         WEBRTC_TRACE(
             kTraceError,
             kTraceFile,
             _id,
             "StartPlaying called, but already playing or recording file %s",
             (_fileName[0] == '\0') ? "(name not set)" : _fileName);
         return -1;
     }
@@ skipping 110 matching lines @@
     _playoutPositionMs = _ptrFileUtilityObj->PlayoutPositionMs();
     _ptrInStream = &stream;
     _notificationMs = notificationTimeMs;
 
     return 0;
 }
 
 int32_t MediaFileImpl::StopPlaying()
 {
 
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     _isStereo = false;
     if(_ptrFileUtilityObj)
     {
         delete _ptrFileUtilityObj;
         _ptrFileUtilityObj = NULL;
     }
     if(_ptrInStream)
     {
         // If MediaFileImpl opened the InStream it must be reclaimed here.
         if(_openFile)
@@ skipping 14 matching lines @@
         return -1;
     }
 
     _playingActive = false;
     return 0;
 }
 
 bool MediaFileImpl::IsPlaying()
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id, "MediaFileImpl::IsPlaying()");
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     return _playingActive;
 }
 
 int32_t MediaFileImpl::IncomingAudioData(
     const int8_t*  buffer,
     const size_t bufferLengthInBytes)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "MediaFile::IncomingData(buffer= 0x%x, bufLen= %" PRIuS,
                  buffer, bufferLengthInBytes);
 
     if(buffer == NULL || bufferLengthInBytes == 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "Buffer pointer or length is NULL!");
         return -1;
     }
 
     bool recordingEnded = false;
     uint32_t callbackNotifyMs = 0;
     {
-        CriticalSectionScoped lock(_crit);
+        rtc::CritScope lock(&_crit);
 
         if(!_recordingActive)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                          "Not currently recording!");
             return -1;
         }
         if(_ptrOutStream == NULL)
         {
             WEBRTC_TRACE(kTraceError, kTraceFile, _id,
@@ skipping 74 matching lines @@
         if(bytesWritten < (int32_t)bufferLengthInBytes)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                          "Failed to write all requested bytes!");
             StopRecording();
             recordingEnded = true;
         }
     }
 
     // Only _callbackCrit may and should be taken when making callbacks.
-    CriticalSectionScoped lock(_callbackCrit);
+    rtc::CritScope lock(&_callbackCrit);
     if(_ptrCallback)
     {
         if(callbackNotifyMs)
         {
             _ptrCallback->RecordNotification(_id, callbackNotifyMs);
         }
         if(recordingEnded)
         {
             _ptrCallback->RecordFileEnded(_id);
             return -1;
@@ skipping 39 matching lines @@
     }
 
     if(StartRecordingAudioStream(*outputStream, format, codecInst,
                                  notificationTimeMs) == -1)
     {
         outputStream->CloseFile();
         delete outputStream;
         return -1;
     }
 
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     _openFile = true;
     strncpy(_fileName, fileName, sizeof(_fileName));
     _fileName[sizeof(_fileName) - 1] = '\0';
     return 0;
 }
 
 int32_t MediaFileImpl::StartRecordingAudioStream(
     OutStream& stream,
     const FileFormats format,
     const CodecInst& codecInst,
     const uint32_t notificationTimeMs)
 {
     // Check codec info
     if(!ValidFileFormat(format,&codecInst))
     {
         return -1;
     }
 
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     if(_recordingActive || _playingActive)
     {
         WEBRTC_TRACE(
             kTraceError,
             kTraceFile,
             _id,
             "StartRecording called, but already recording or playing file %s!",
                    _fileName);
         return -1;
     }
@@ skipping 116 matching lines @@
     _recordingActive = true;
     _ptrOutStream = &stream;
     _notificationMs = notificationTimeMs;
     _recordDurationMs = 0;
     return 0;
 }
 
 int32_t MediaFileImpl::StopRecording()
 {
 
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     if(!_recordingActive)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                      "recording is not active!");
         return -1;
     }
 
     _isStereo = false;
 
     if(_ptrFileUtilityObj != NULL)
@@ skipping 23 matching lines @@
     _recordingActive = false;
     codec_info_.pltype = 0;
     codec_info_.plname[0] = '\0';
 
     return 0;
 }
 
 bool MediaFileImpl::IsRecording()
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id, "MediaFileImpl::IsRecording()");
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     return _recordingActive;
 }
 
 int32_t MediaFileImpl::RecordDurationMs(uint32_t& durationMs)
 {
 
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     if(!_recordingActive)
     {
         durationMs = 0;
         return -1;
     }
     durationMs = _recordDurationMs;
     return 0;
 }
 
 bool MediaFileImpl::IsStereo()
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id, "MediaFileImpl::IsStereo()");
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     return _isStereo;
 }
 
 int32_t MediaFileImpl::SetModuleFileCallback(FileCallback* callback)
 {
 
-    CriticalSectionScoped lock(_callbackCrit);
+    rtc::CritScope lock(&_callbackCrit);
 
     _ptrCallback = callback;
     return 0;
 }
 
 int32_t MediaFileImpl::FileDurationMs(const char* fileName,
                                       uint32_t& durationMs,
                                       const FileFormats format,
                                       const uint32_t freqInHz)
 {
@@ skipping 23 matching lines @@
         durationMs = 0;
         return -1;
     }
 
     durationMs = duration;
     return 0;
 }
 
 int32_t MediaFileImpl::PlayoutPositionMs(uint32_t& positionMs) const
 {
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     if(!_playingActive)
     {
         positionMs = 0;
         return -1;
     }
     positionMs = _playoutPositionMs;
     return 0;
 }
 
 int32_t MediaFileImpl::codec_info(CodecInst& codecInst) const
 {
-    CriticalSectionScoped lock(_crit);
+    rtc::CritScope lock(&_crit);
     if(!_playingActive && !_recordingActive)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "Neither playout nor recording has been initialized!");
         return -1;
     }
     if (codec_info_.pltype == 0 && codec_info_.plname[0] == '\0')
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "The CodecInst for %s is unknown!",
@@ skipping 59 matching lines @@
 {
     if((frequency == 8000) || (frequency == 16000)|| (frequency == 32000))
     {
         return true;
     }
     WEBRTC_TRACE(kTraceError, kTraceFile, -1,
                  "Frequency should be 8000, 16000 or 32000 (Hz)");
     return false;
 }
 }  // namespace webrtc