FileRecorder + FilePlayer: Let Create functions return unique_ptr

webrtc/voice_engine/transmit_mixer.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 164 matching lines @@
         mixer = NULL;
     }
 }
 
 TransmitMixer::TransmitMixer(uint32_t instanceId) :
     _engineStatisticsPtr(NULL),
     _channelManagerPtr(NULL),
     audioproc_(NULL),
     _voiceEngineObserverPtr(NULL),
     _processThreadPtr(NULL),
-    _filePlayerPtr(NULL),
-    _fileRecorderPtr(NULL),
-    _fileCallRecorderPtr(NULL),
     // Avoid conflict with other channels by adding 1024 - 1026,
     // won't use as much as 1024 channels.
     _filePlayerId(instanceId + 1024),
     _fileRecorderId(instanceId + 1025),
     _fileCallRecorderId(instanceId + 1026),
     _filePlaying(false),
     _fileRecording(false),
     _fileCallRecording(false),
     _audioLevel(),
 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
@@ skipping 20 matching lines @@
                  "TransmitMixer::~TransmitMixer() - dtor");
     _monitorModule.DeRegisterObserver();
     if (_processThreadPtr)
     {
         _processThreadPtr->DeRegisterModule(&_monitorModule);
     }
     DeRegisterExternalMediaProcessing(kRecordingAllChannelsMixed);
     DeRegisterExternalMediaProcessing(kRecordingPreprocessing);
     {
         rtc::CritScope cs(&_critSect);
-        if (_fileRecorderPtr)
-        {
-            _fileRecorderPtr->RegisterModuleFileCallback(NULL);
-            _fileRecorderPtr->StopRecording();
-            FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
-            _fileRecorderPtr = NULL;
+        if (file_recorder_) {
+          file_recorder_->RegisterModuleFileCallback(NULL);
+          file_recorder_->StopRecording();
         }
-        if (_fileCallRecorderPtr)
-        {
-            _fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
-            _fileCallRecorderPtr->StopRecording();
-            FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
-            _fileCallRecorderPtr = NULL;
+        if (file_call_recorder_) {
+          file_call_recorder_->RegisterModuleFileCallback(NULL);
+          file_call_recorder_->StopRecording();
         }
-        if (_filePlayerPtr)
-        {
-            _filePlayerPtr->RegisterModuleFileCallback(NULL);
-            _filePlayerPtr->StopPlayingFile();
-            FilePlayer::DestroyFilePlayer(_filePlayerPtr);
-            _filePlayerPtr = NULL;
+        if (file_player_) {
+          file_player_->RegisterModuleFileCallback(NULL);
+          file_player_->StopPlayingFile();
         }
     }
 }
 
 int32_t
 TransmitMixer::SetEngineInformation(ProcessThread& processThread,
                                     Statistics& engineStatistics,
                                     ChannelManager& channelManager)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
@@ skipping 231 matching lines @@
     {
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_PLAYING, kTraceWarning,
             "StartPlayingFileAsMicrophone() is already playing");
         return 0;
     }
 
     rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
-    if (_filePlayerPtr)
-    {
-        _filePlayerPtr->RegisterModuleFileCallback(NULL);
-        FilePlayer::DestroyFilePlayer(_filePlayerPtr);
-        _filePlayerPtr = NULL;
+    if (file_player_) {
+      file_player_->RegisterModuleFileCallback(NULL);
+      file_player_.reset();
     }
 
     // Dynamically create the instance
-    _filePlayerPtr
-        = FilePlayer::CreateFilePlayer(_filePlayerId,
-                                       (const FileFormats) format);
+    file_player_ =
+        FilePlayer::NewFilePlayer(_filePlayerId, (const FileFormats)format);
 
-    if (_filePlayerPtr == NULL)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_ARGUMENT, kTraceError,
-            "StartPlayingFileAsMicrophone() filePlayer format isnot correct");
-        return -1;
+    if (!file_player_) {
+      _engineStatisticsPtr->SetLastError(
+          VE_INVALID_ARGUMENT, kTraceError,
+          "StartPlayingFileAsMicrophone() filePlayer format isnot correct");
+      return -1;
     }
 
     const uint32_t notificationTime(0);
 
-    if (_filePlayerPtr->StartPlayingFile(
-        fileName,
-        loop,
-        startPosition,
-        volumeScaling,
-        notificationTime,
-        stopPosition,
-        (const CodecInst*) codecInst) != 0)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_FILE, kTraceError,
-            "StartPlayingFile() failed to start file playout");
-        _filePlayerPtr->StopPlayingFile();
-        FilePlayer::DestroyFilePlayer(_filePlayerPtr);
-        _filePlayerPtr = NULL;
-        return -1;
+    if (file_player_->StartPlayingFile(
+            fileName, loop, startPosition, volumeScaling, notificationTime,
+            stopPosition, (const CodecInst*)codecInst) != 0) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_FILE, kTraceError,
+          "StartPlayingFile() failed to start file playout");
+      file_player_->StopPlayingFile();
+      file_player_.reset();
+      return -1;
     }
 
-    _filePlayerPtr->RegisterModuleFileCallback(this);
+    file_player_->RegisterModuleFileCallback(this);
     _filePlaying = true;
 
     return 0;
 }
 
 int TransmitMixer::StartPlayingFileAsMicrophone(InStream* stream,
                                                 FileFormats format,
                                                 int startPosition,
                                                 float volumeScaling,
                                                 int stopPosition,
@@ skipping 16 matching lines @@
     {
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_PLAYING, kTraceWarning,
             "StartPlayingFileAsMicrophone() is already playing");
         return 0;
     }
 
     rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
-    if (_filePlayerPtr)
-    {
-        _filePlayerPtr->RegisterModuleFileCallback(NULL);
-        FilePlayer::DestroyFilePlayer(_filePlayerPtr);
-        _filePlayerPtr = NULL;
+    if (file_player_) {
+      file_player_->RegisterModuleFileCallback(NULL);
+      file_player_.reset();
     }
 
     // Dynamically create the instance
-    _filePlayerPtr
-        = FilePlayer::CreateFilePlayer(_filePlayerId,
-                                       (const FileFormats) format);
+    file_player_ =
+        FilePlayer::NewFilePlayer(_filePlayerId, (const FileFormats)format);
 
-    if (_filePlayerPtr == NULL)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_ARGUMENT, kTraceWarning,
-            "StartPlayingFileAsMicrophone() filePlayer format isnot correct");
-        return -1;
+    if (!file_player_) {
+      _engineStatisticsPtr->SetLastError(
+          VE_INVALID_ARGUMENT, kTraceWarning,
+          "StartPlayingFileAsMicrophone() filePlayer format isnot correct");
+      return -1;
     }
 
     const uint32_t notificationTime(0);
 
-    if (_filePlayerPtr->StartPlayingFile(
-        (InStream&) *stream,
-        startPosition,
-        volumeScaling,
-        notificationTime,
-        stopPosition,
-        (const CodecInst*) codecInst) != 0)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_FILE, kTraceError,
-            "StartPlayingFile() failed to start file playout");
-        _filePlayerPtr->StopPlayingFile();
-        FilePlayer::DestroyFilePlayer(_filePlayerPtr);
-        _filePlayerPtr = NULL;
-        return -1;
+    if (file_player_->StartPlayingFile(
+            (InStream&)*stream, startPosition, volumeScaling, notificationTime,
+            stopPosition, (const CodecInst*)codecInst) != 0) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_FILE, kTraceError,
+          "StartPlayingFile() failed to start file playout");
+      file_player_->StopPlayingFile();
+      file_player_.reset();
+      return -1;
     }
-    _filePlayerPtr->RegisterModuleFileCallback(this);
+    file_player_->RegisterModuleFileCallback(this);
     _filePlaying = true;
 
     return 0;
 }
 
 int TransmitMixer::StopPlayingFileAsMicrophone()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
                  "TransmitMixer::StopPlayingFileAsMicrophone()");
 
     if (!_filePlaying)
     {
         return 0;
     }
 
     rtc::CritScope cs(&_critSect);
 
-    if (_filePlayerPtr->StopPlayingFile() != 0)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_CANNOT_STOP_PLAYOUT, kTraceError,
-            "StopPlayingFile() couldnot stop playing file");
-        return -1;
+    if (file_player_->StopPlayingFile() != 0) {
+      _engineStatisticsPtr->SetLastError(
+          VE_CANNOT_STOP_PLAYOUT, kTraceError,
+          "StopPlayingFile() couldnot stop playing file");
+      return -1;
     }
 
-    _filePlayerPtr->RegisterModuleFileCallback(NULL);
-    FilePlayer::DestroyFilePlayer(_filePlayerPtr);
-    _filePlayerPtr = NULL;
+    file_player_->RegisterModuleFileCallback(NULL);
+    file_player_.reset();
     _filePlaying = false;
 
     return 0;
 }
 
 int TransmitMixer::IsPlayingFileAsMicrophone() const
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::IsPlayingFileAsMicrophone()");
     return _filePlaying;
@@ skipping 34 matching lines @@
         (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
     {
         format = kFileFormatWavFile;
     } else
     {
         format = kFileFormatCompressedFile;
     }
 
     // Destroy the old instance
-    if (_fileRecorderPtr)
-    {
-        _fileRecorderPtr->RegisterModuleFileCallback(NULL);
-        FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
-        _fileRecorderPtr = NULL;
+    if (file_recorder_) {
+      file_recorder_->RegisterModuleFileCallback(NULL);
+      file_recorder_.reset();
     }
 
-    _fileRecorderPtr =
-        FileRecorder::CreateFileRecorder(_fileRecorderId,
-                                         (const FileFormats) format);
-    if (_fileRecorderPtr == NULL)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_ARGUMENT, kTraceError,
-            "StartRecordingMicrophone() fileRecorder format isnot correct");
-        return -1;
+    file_recorder_ = FileRecorder::CreateFileRecorder(
+        _fileRecorderId, (const FileFormats)format);
+    if (!file_recorder_) {
+      _engineStatisticsPtr->SetLastError(
+          VE_INVALID_ARGUMENT, kTraceError,
+          "StartRecordingMicrophone() fileRecorder format isnot correct");
+      return -1;
     }
 
-    if (_fileRecorderPtr->StartRecordingAudioFile(
-        fileName,
-        (const CodecInst&) *codecInst,
-        notificationTime) != 0)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_FILE, kTraceError,
-            "StartRecordingAudioFile() failed to start file recording");
-        _fileRecorderPtr->StopRecording();
-        FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
-        _fileRecorderPtr = NULL;
-        return -1;
+    if (file_recorder_->StartRecordingAudioFile(
+            fileName, (const CodecInst&)*codecInst, notificationTime) != 0) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_FILE, kTraceError,
+          "StartRecordingAudioFile() failed to start file recording");
+      file_recorder_->StopRecording();
+      file_recorder_.reset();
+      return -1;
     }
-    _fileRecorderPtr->RegisterModuleFileCallback(this);
+    file_recorder_->RegisterModuleFileCallback(this);
     _fileRecording = true;
 
     return 0;
 }
 
 int TransmitMixer::StartRecordingMicrophone(OutStream* stream,
                                             const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                "TransmitMixer::StartRecordingMicrophone()");
@@ skipping 26 matching lines @@
         (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
     {
         format = kFileFormatWavFile;
     } else
     {
         format = kFileFormatCompressedFile;
     }
 
     // Destroy the old instance
-    if (_fileRecorderPtr)
-    {
-        _fileRecorderPtr->RegisterModuleFileCallback(NULL);
-        FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
-        _fileRecorderPtr = NULL;
+    if (file_recorder_) {
+      file_recorder_->RegisterModuleFileCallback(NULL);
+      file_recorder_.reset();
     }
 
-    _fileRecorderPtr =
-        FileRecorder::CreateFileRecorder(_fileRecorderId,
-                                         (const FileFormats) format);
-    if (_fileRecorderPtr == NULL)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_ARGUMENT, kTraceError,
-            "StartRecordingMicrophone() fileRecorder format isnot correct");
-        return -1;
+    file_recorder_ = FileRecorder::CreateFileRecorder(
+        _fileRecorderId, (const FileFormats)format);
+    if (!file_recorder_) {
+      _engineStatisticsPtr->SetLastError(
+          VE_INVALID_ARGUMENT, kTraceError,
+          "StartRecordingMicrophone() fileRecorder format isnot correct");
+      return -1;
     }
 
-    if (_fileRecorderPtr->StartRecordingAudioFile(*stream,
-                                                  *codecInst,
-                                                  notificationTime) != 0)
-    {
-    _engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
-      "StartRecordingAudioFile() failed to start file recording");
-    _fileRecorderPtr->StopRecording();
-    FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
-    _fileRecorderPtr = NULL;
-    return -1;
+    if (file_recorder_->StartRecordingAudioFile(*stream, *codecInst,
+                                                notificationTime) != 0) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_FILE, kTraceError,
+          "StartRecordingAudioFile() failed to start file recording");
+      file_recorder_->StopRecording();
+      file_recorder_.reset();
+      return -1;
     }
 
-    _fileRecorderPtr->RegisterModuleFileCallback(this);
+    file_recorder_->RegisterModuleFileCallback(this);
     _fileRecording = true;
 
     return 0;
 }
 
 
 int TransmitMixer::StopRecordingMicrophone()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::StopRecordingMicrophone()");
 
     rtc::CritScope cs(&_critSect);
 
     if (!_fileRecording)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                    "StopRecordingMicrophone() isnot recording");
         return 0;
     }
 
-    if (_fileRecorderPtr->StopRecording() != 0)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_STOP_RECORDING_FAILED, kTraceError,
-            "StopRecording(), could not stop recording");
-        return -1;
+    if (file_recorder_->StopRecording() != 0) {
+      _engineStatisticsPtr->SetLastError(
+          VE_STOP_RECORDING_FAILED, kTraceError,
+          "StopRecording(), could not stop recording");
+      return -1;
     }
-    _fileRecorderPtr->RegisterModuleFileCallback(NULL);
-    FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
-    _fileRecorderPtr = NULL;
+    file_recorder_->RegisterModuleFileCallback(NULL);
+    file_recorder_.reset();
     _fileRecording = false;
 
     return 0;
 }
 
 int TransmitMixer::StartRecordingCall(const char* fileName,
                                       const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::StartRecordingCall(fileName=%s)", fileName);
@@ skipping 26 matching lines @@
     {
         format = kFileFormatWavFile;
     } else
     {
         format = kFileFormatCompressedFile;
     }
 
     rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
-    if (_fileCallRecorderPtr)
-    {
-        _fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
-        FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
-        _fileCallRecorderPtr = NULL;
+    if (file_call_recorder_) {
+      file_call_recorder_->RegisterModuleFileCallback(NULL);
+      file_call_recorder_.reset();
     }
 
-    _fileCallRecorderPtr
-        = FileRecorder::CreateFileRecorder(_fileCallRecorderId,
-                                           (const FileFormats) format);
-    if (_fileCallRecorderPtr == NULL)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_ARGUMENT, kTraceError,
-            "StartRecordingCall() fileRecorder format isnot correct");
-        return -1;
+    file_call_recorder_ = FileRecorder::CreateFileRecorder(
+        _fileCallRecorderId, (const FileFormats)format);
+    if (!file_call_recorder_) {
+      _engineStatisticsPtr->SetLastError(
+          VE_INVALID_ARGUMENT, kTraceError,
+          "StartRecordingCall() fileRecorder format isnot correct");
+      return -1;
     }
 
-    if (_fileCallRecorderPtr->StartRecordingAudioFile(
-        fileName,
-        (const CodecInst&) *codecInst,
-        notificationTime) != 0)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_FILE, kTraceError,
-            "StartRecordingAudioFile() failed to start file recording");
-        _fileCallRecorderPtr->StopRecording();
-        FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
-        _fileCallRecorderPtr = NULL;
-        return -1;
+    if (file_call_recorder_->StartRecordingAudioFile(
+            fileName, (const CodecInst&)*codecInst, notificationTime) != 0) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_FILE, kTraceError,
+          "StartRecordingAudioFile() failed to start file recording");
+      file_call_recorder_->StopRecording();
+      file_call_recorder_.reset();
+      return -1;
     }
-    _fileCallRecorderPtr->RegisterModuleFileCallback(this);
+    file_call_recorder_->RegisterModuleFileCallback(this);
     _fileCallRecording = true;
 
     return 0;
 }
 
 int TransmitMixer::StartRecordingCall(OutStream* stream,
                                       const  CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::StartRecordingCall()");
@@ skipping 26 matching lines @@
     {
         format = kFileFormatWavFile;
     } else
     {
         format = kFileFormatCompressedFile;
     }
 
     rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
-    if (_fileCallRecorderPtr)
-    {
-        _fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
-        FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
-        _fileCallRecorderPtr = NULL;
+    if (file_call_recorder_) {
+      file_call_recorder_->RegisterModuleFileCallback(NULL);
+      file_call_recorder_.reset();
     }
 
-    _fileCallRecorderPtr =
-        FileRecorder::CreateFileRecorder(_fileCallRecorderId,
-                                         (const FileFormats) format);
-    if (_fileCallRecorderPtr == NULL)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_ARGUMENT, kTraceError,
-            "StartRecordingCall() fileRecorder format isnot correct");
-        return -1;
+    file_call_recorder_ = FileRecorder::CreateFileRecorder(
+        _fileCallRecorderId, (const FileFormats)format);
+    if (!file_call_recorder_) {
+      _engineStatisticsPtr->SetLastError(
+          VE_INVALID_ARGUMENT, kTraceError,
+          "StartRecordingCall() fileRecorder format isnot correct");
+      return -1;
     }
 
-    if (_fileCallRecorderPtr->StartRecordingAudioFile(*stream,
-                                                      *codecInst,
-                                                      notificationTime) != 0)
-    {
-    _engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
-     "StartRecordingAudioFile() failed to start file recording");
-    _fileCallRecorderPtr->StopRecording();
-    FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
-    _fileCallRecorderPtr = NULL;
-    return -1;
+    if (file_call_recorder_->StartRecordingAudioFile(*stream, *codecInst,
+                                                     notificationTime) != 0) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_FILE, kTraceError,
+          "StartRecordingAudioFile() failed to start file recording");
+      file_call_recorder_->StopRecording();
+      file_call_recorder_.reset();
+      return -1;
     }
 
-    _fileCallRecorderPtr->RegisterModuleFileCallback(this);
+    file_call_recorder_->RegisterModuleFileCallback(this);
     _fileCallRecording = true;
 
     return 0;
 }
 
 int TransmitMixer::StopRecordingCall()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::StopRecordingCall()");
 
     if (!_fileCallRecording)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
                      "StopRecordingCall() file isnot recording");
         return -1;
     }
 
     rtc::CritScope cs(&_critSect);
 
-    if (_fileCallRecorderPtr->StopRecording() != 0)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_STOP_RECORDING_FAILED, kTraceError,
-            "StopRecording(), could not stop recording");
-        return -1;
+    if (file_call_recorder_->StopRecording() != 0) {
+      _engineStatisticsPtr->SetLastError(
+          VE_STOP_RECORDING_FAILED, kTraceError,
+          "StopRecording(), could not stop recording");
+      return -1;
     }
 
-    _fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
-    FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
-    _fileCallRecorderPtr = NULL;
+    file_call_recorder_->RegisterModuleFileCallback(NULL);
+    file_call_recorder_.reset();
     _fileCallRecording = false;
 
     return 0;
 }
 
 void
 TransmitMixer::SetMixWithMicStatus(bool mix)
 {
     _mixFileWithMicrophone = mix;
 }
@@ skipping 93 matching lines @@
   }
   _audioFrame.num_channels_ = std::min(num_channels, num_codec_channels);
   RemixAndResample(audio, samples_per_channel, num_channels, sample_rate_hz,
                    &resampler_, &_audioFrame);
 }
 
 int32_t TransmitMixer::RecordAudioToFile(
     uint32_t mixingFrequency)
 {
     rtc::CritScope cs(&_critSect);
-    if (_fileRecorderPtr == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                     "TransmitMixer::RecordAudioToFile() filerecorder doesnot"
-                     "exist");
-        return -1;
+    if (!file_recorder_) {
+      WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
+                   "TransmitMixer::RecordAudioToFile() filerecorder doesnot"
+                   "exist");
+      return -1;
     }
 
-    if (_fileRecorderPtr->RecordAudioToFile(_audioFrame) != 0)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                     "TransmitMixer::RecordAudioToFile() file recording"
-                     "failed");
-        return -1;
+    if (file_recorder_->RecordAudioToFile(_audioFrame) != 0) {
+      WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
+                   "TransmitMixer::RecordAudioToFile() file recording"
+                   "failed");
+      return -1;
     }
 
     return 0;
 }
 
 int32_t TransmitMixer::MixOrReplaceAudioWithFile(
     int mixingFrequency)
 {
     std::unique_ptr<int16_t[]> fileBuffer(new int16_t[640]);
 
     size_t fileSamples(0);
     {
         rtc::CritScope cs(&_critSect);
-        if (_filePlayerPtr == NULL)
-        {
-            WEBRTC_TRACE(kTraceWarning, kTraceVoice,
-                         VoEId(_instanceId, -1),
-                         "TransmitMixer::MixOrReplaceAudioWithFile()"
-                         "fileplayer doesnot exist");
-            return -1;
+        if (!file_player_) {
+          WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
+                       "TransmitMixer::MixOrReplaceAudioWithFile()"
+                       "fileplayer doesnot exist");
+          return -1;
         }
 
-        if (_filePlayerPtr->Get10msAudioFromFile(fileBuffer.get(),
-                                                 fileSamples,
-                                                 mixingFrequency) == -1)
-        {
-            WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                         "TransmitMixer::MixOrReplaceAudioWithFile() file"
-                         " mixing failed");
-            return -1;
+        if (file_player_->Get10msAudioFromFile(fileBuffer.get(), fileSamples,
+                                               mixingFrequency) == -1) {
+          WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
+                       "TransmitMixer::MixOrReplaceAudioWithFile() file"
+                       " mixing failed");
+          return -1;
         }
     }
 
     assert(_audioFrame.samples_per_channel_ == fileSamples);
 
     if (_mixFileWithMicrophone)
     {
         // Currently file stream is always mono.
         // TODO(xians): Change the code when FilePlayer supports real stereo.
         MixWithSat(_audioFrame.data_,
@@ skipping 113 matching lines @@
 void TransmitMixer::EnableStereoChannelSwapping(bool enable) {
   swap_stereo_channels_ = enable;
 }
 
 bool TransmitMixer::IsStereoChannelSwappingEnabled() {
   return swap_stereo_channels_;
 }
 
 }  // namespace voe
 }  // namespace webrtc